Pix* edgeBinarize(Pix* pix){
FUNCNAME("edgeBinarize");
#if HAS_ADAPTIVE_BINARIZER
PixAdaptiveBinarizer binarizer(false);
return binarizer.bradleyAdaptiveThresholding(pix, 0.15, 8);
#endif
Pix* result;
pixOtsuAdaptiveThreshold(pix, pixGetWidth(pix), pixGetHeight(pix), 0, 0, 0.1, NULL, &result);
pixCopyResolution(result, pix);
return result;
}
CFX_ByteString CBC_QRCodeReader::Decode(CFX_DIBitmap* pBitmap,
int32_t hints,
int32_t byteModeDecode,
int32_t& e) {
CBC_BufferedImageLuminanceSource source(pBitmap);
CBC_GlobalHistogramBinarizer binarizer(&source);
CBC_BinaryBitmap bitmap(&binarizer);
CFX_ByteString bs = Decode(&bitmap, hints, e);
BC_EXCEPTION_CHECK_ReturnValue(e, "");
return bs;
}
Pix* binarize(Pix* pix, ProgressCallback* callback) {
FUNCNAME("binarize");
Pix *pixb;
#ifdef HAS_ADAPTIVE_BINARIZER
PixBinarizer binarizer(false);
pixb = binarizer.binarize(pix, callback);
#else
pixb = binarizeTiled(pix, NULL);
#endif
pixCopyResolution(pixb, pix);
return pixb;
}
void PrepareAllFeaturesTest(const THashSet<int>& categFeatures,
const TVector<TFloatFeature>& floatFeatures,
const TAllFeatures& learnFeatures,
ENanMode nanMode,
bool clearPool,
NPar::TLocalExecutor& localExecutor,
const TVector<size_t>& selectedDocIndices,
TDocumentStorage* testDocStorage,
TAllFeatures* testFeatures) {
if (testDocStorage->GetDocCount() == 0) {
return;
}
TBinarizer binarizer(testDocStorage->GetFactorsCount(), categFeatures, floatFeatures, nanMode, localExecutor);
binarizer.SetupToIgnoreFeaturesAfter(learnFeatures);
PrepareSlotsAfter(learnFeatures, testFeatures);
binarizer.Binarize(/*forLearn=*/false, testDocStorage, selectedDocIndices, clearPool, testFeatures);
DumpMemUsage("Extract bools done");
}
void PrepareAllFeaturesLearn(const THashSet<int>& categFeatures,
const TVector<TFloatFeature>& floatFeatures,
const TVector<int>& ignoredFeatures,
bool ignoreRedundantCatFeatures,
size_t oneHotMaxSize,
ENanMode nanMode,
bool clearPool,
NPar::TLocalExecutor& localExecutor,
const TVector<size_t>& selectedDocIndices,
TDocumentStorage* learnDocStorage,
TAllFeatures* learnFeatures) {
if (learnDocStorage->GetDocCount() == 0) {
return;
}
TBinarizer binarizer(learnDocStorage->GetFactorsCount(), categFeatures, floatFeatures, nanMode, localExecutor);
binarizer.SetupToIgnoreFeatures(ignoredFeatures, ignoreRedundantCatFeatures);
PrepareSlots(binarizer.GetCatFeatureCount(), binarizer.GetFloatFeatureCount(), learnFeatures);
binarizer.Binarize(/*forLearn=*/true, learnDocStorage, selectedDocIndices, clearPool, learnFeatures);
CleanupOneHotFeatures(oneHotMaxSize, learnFeatures);
CB_ENSURE(learnFeatures->GetDocCount() > 0, "Train dataset is empty after binarization");
DumpMemUsage("Extract bools done");
}
void QRcodeReader::decode() {
Binarizer binarizer(img);
img = binarizer.getBlackMatrix();
if (more) {
imshow("original", rgbImg);
imshow("test",img);
waitKey(0);
printf("**************************************************************\n");
printf("Begin detection to find the three finder pattern centers:\n");
}
Finder finder = Finder(img);
FinderResult fr = finder.find();
if (more) {
printf("\n");
printf("Three finder pattern centers:\n");
FinderPoint bL = fr.getBottomLeft();
FinderPoint tL = fr.getTopLeft();
FinderPoint tR = fr.getTopRight();
printf("bottomLeft: (%f, %f)\n", bL.getX(), bL.getY());
printf("topLeft: (%f, %f)\n", tL.getX(), tL.getY());
printf("topRight: (%f, %f)\n", tR.getX(), tR.getY());
Point2f p1 = Point2f(bL.getX(), bL.getY());
circle(rgbImg, p1, 3, Scalar(0,255,0));
Point2f p2 = Point2f(tL.getX(), tL.getY());
circle(rgbImg, p2, 3, Scalar(0,255,0));
Point2f p3 = Point2f(tR.getX(), tR.getY());
circle(rgbImg, p3, 3, Scalar(0,255,0));
imshow("original", rgbImg);
waitKey(0);
}
Detector detector = Detector(img);
DetectorResult detectorResult = detector.processFinderPatternInfo(fr);
if (more) {
vector<FinderPoint> patternPoints = detectorResult.getResultPoints();
BitMatrix bits = detectorResult.getBits();
printf("\n");
printf("Module Size: %f\n", detectorResult.getModuleSize());
printf("Dimension: %d\n", detectorResult.getDimension());
printf("Alignment Pattern : (%f, %f)\n", patternPoints[3].getX(), patternPoints[3].getY());
Point2f p4 = Point2f(patternPoints[3].getX(), patternPoints[3].getY());
circle(rgbImg, p4, 3, Scalar(0,255,0));
imshow("original", rgbImg);
waitKey(0);
printf("\n");
printf("The bit matrix:\n");
bits.display();
printf("\nDetection Done!\n");
printf("**************************************************************\n");
waitKey(0);
}
Decoder decoder = Decoder(detectorResult);
DecoderResult decoderResult = decoder.decode();
if (more) {
printf("Decode:\n");
printf("version : %d\n", decoderResult.getVersion());
printf("Error correct level : %d\n", decoderResult.getEcLevel());
vector<char> resultBytes = decoderResult.getResultBytes();
printf("Data bytes: ");
for (int i = 0; i < resultBytes.size(); ++i) {
printf("%d ",resultBytes[i]);
}
printf("\n");
string result = decoderResult.getResultText();
printf("%s\n", result.c_str());
waitKey(0);
}
else {
string result = decoderResult.getResultText();
printf("%s\n", result.c_str());
}
}
Pix* binarizeAdaptive(Pix* pix) {
PixAdaptiveBinarizer binarizer(false);
Pix* pixb = binarizer.bradleyAdaptiveThresholding(pix, 0.11, 30);
pixCopyResolution(pixb, pix);
return pixb;
}
