cpp/cli/src/main.cpp - platform/external/zxing - Git at Google

 // -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
 /*
  *  Copyright 2010-2011 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.
  */

 #include <iostream>
 #include <fstream>
 #include <string>
 #include "ImageReaderSource.h"
 #include <zxing/common/Counted.h>
 #include <zxing/Binarizer.h>
 #include <zxing/MultiFormatReader.h>
 #include <zxing/Result.h>
 #include <zxing/ReaderException.h>
 #include <zxing/common/GlobalHistogramBinarizer.h>
 #include <zxing/common/HybridBinarizer.h>
 #include <exception>
 #include <zxing/Exception.h>
 #include <zxing/common/IllegalArgumentException.h>
 #include <zxing/BinaryBitmap.h>
 #include <zxing/DecodeHints.h>

 #include <zxing/qrcode/QRCodeReader.h>
 #include <zxing/multi/qrcode/QRCodeMultiReader.h>
 #include <zxing/multi/ByQuadrantReader.h>
 #include <zxing/multi/MultipleBarcodeReader.h>
 #include <zxing/multi/GenericMultipleBarcodeReader.h>

 using namespace std;
 using namespace zxing;
 using namespace zxing::multi;
 using namespace zxing::qrcode;

 namespace {

 bool more = false;
 bool test_mode = false;
 bool try_harder = false;
 bool search_multi = false;
 bool use_hybrid = false;
 bool use_global = false;
 bool verbose = false;

 }

 vector<Ref<Result> > decode(Ref<BinaryBitmap> image, DecodeHints hints) {
   Ref<Reader> reader(new MultiFormatReader);
   return vector<Ref<Result> >(1, reader->decode(image, hints));
 }

 vector<Ref<Result> > decode_multi(Ref<BinaryBitmap> image, DecodeHints hints) {
   MultiFormatReader delegate;
   GenericMultipleBarcodeReader reader(delegate);
   return reader.decodeMultiple(image, hints);
 }

 int read_image(Ref<LuminanceSource> source, bool hybrid, string expected) {
   vector<Ref<Result> > results;
   string cell_result;
   int res = -1;

   try {
     Ref<Binarizer> binarizer;
     if (hybrid) {
       binarizer = new HybridBinarizer(source);
     } else {
       binarizer = new GlobalHistogramBinarizer(source);
     }
     DecodeHints hints(DecodeHints::DEFAULT_HINT);
     hints.setTryHarder(try_harder);
     Ref<BinaryBitmap> binary(new BinaryBitmap(binarizer));
     if (search_multi) {
       results = decode_multi(binary, hints);
     } else {
       results = decode(binary, hints);
     }
     res = 0;
   } catch (const ReaderException& e) {
     cell_result = "zxing::ReaderException: " + string(e.what());
     res = -2;
   } catch (const zxing::IllegalArgumentException& e) {
     cell_result = "zxing::IllegalArgumentException: " + string(e.what());
     res = -3;
   } catch (const zxing::Exception& e) {
     cell_result = "zxing::Exception: " + string(e.what());
     res = -4;
   } catch (const std::exception& e) {
     cell_result = "std::exception: " + string(e.what());
     res = -5;
   }

   if (test_mode && results.size() == 1) {
     std::string result = results[0]->getText()->getText();
     if (expected.empty()) {
       cout << "  Expected text or binary data for image missing." << endl
            << "  Detected: " << result << endl;
       res = -6;
     } else {
       if (expected.compare(result) != 0) {
         cout << "  Expected: " << expected << endl
              << "  Detected: " << result << endl;
         cell_result = "data did not match";
         res = -6;
       }
     }
   }

   if (res != 0 && (verbose || (use_global ^ use_hybrid))) {
     cout << (hybrid ? "Hybrid" : "Global")
          << " binarizer failed: " << cell_result << endl;
   } else if (!test_mode) {
     if (verbose) {
       cout << (hybrid ? "Hybrid" : "Global")
            << " binarizer succeeded: " << endl;
     }
     for (size_t i = 0; i < results.size(); i++) {
       if (more) {
         cout << "  Format: "
              << BarcodeFormat::barcodeFormatNames[results[i]->getBarcodeFormat()]
              << endl;
         for (int j = 0; j < results[i]->getResultPoints()->size(); j++) {
           cout << "  Point[" << j <<  "]: "
                << results[i]->getResultPoints()[j]->getX() << " "
                << results[i]->getResultPoints()[j]->getY() << endl;
         }
       }
       if (verbose) {
         cout << "    ";
       }
       cout << results[i]->getText()->getText() << endl;
     }
   }

   return res;
 }

 string read_expected(string imagefilename) {
   string textfilename = imagefilename;
   string::size_type dotpos = textfilename.rfind(".");

   textfilename.replace(dotpos + 1, textfilename.length() - dotpos - 1, "txt");
   ifstream textfile(textfilename.c_str(), ios::binary);
   textfilename.replace(dotpos + 1, textfilename.length() - dotpos - 1, "bin");
   ifstream binfile(textfilename.c_str(), ios::binary);
   ifstream *file = 0;
   if (textfile.is_open()) {
     file = &textfile;
   } else if (binfile.is_open()) {
     file = &binfile;
   } else {
     return std::string();
   }
   file->seekg(0, ios_base::end);
   size_t size = size_t(file->tellg());
   file->seekg(0, ios_base::beg);

   if (size == 0) {
     return std::string();
   }

   char* data = new char[size + 1];
   file->read(data, size);
   data[size] = '\0';
   string expected(data);
   delete[] data;

   return expected;
 }

 int main(int argc, char** argv) {
   if (argc <= 1) {
     cout << "Usage: " << argv[0] << " [OPTION]... <IMAGE>..." << endl
          << "Read barcodes from each IMAGE file." << endl
          << endl
          << "Options:" << endl
          << "  (-h|--hybrid)             use the hybrid binarizer (default)" << endl
          << "  (-g|--global)             use the global binarizer" << endl
          << "  (-v|--verbose)            chattier results printing" << endl
          << "  --more                    display more information about the barcode" << endl
          << "  --test-mode               compare IMAGEs against text files" << endl
          << "  --try-harder              spend more time to try to find a barcode" << endl
          << "  --search-multi            search for more than one bar code" << endl
          << endl
          << "Example usage:" << endl
          << "  zxing --test-mode *.jpg" << endl
          << endl;
     return 1;
   }

   int total = 0;
   int gonly = 0;
   int honly = 0;
   int both = 0;
   int neither = 0;

   for (int i = 1; i < argc; i++) {
     string filename = argv[i];
     if (filename.compare("--verbose") == 0 ||
         filename.compare("-v") == 0) {
       verbose = true;
       continue;
     }
     if (filename.compare("--hybrid") == 0 ||
         filename.compare("-h") == 0) {
       use_hybrid = true;
       continue;
     }
     if (filename.compare("--global") == 0 ||
         filename.compare("-g") == 0) {
       use_global = true;
       continue;
     }
     if (filename.compare("--more") == 0) {
       more = true;
       continue;
     }
     if (filename.compare("--test-mode") == 0) {
       test_mode = true;
       continue;
     }
     if (filename.compare("--try-harder") == 0) {
       try_harder = true;
       continue;
     }
     if (filename.compare("--search-multi") == 0){
       search_multi = true;
       continue;
     }

     if (filename.length() > 3 &&
         (filename.substr(filename.length() - 3, 3).compare("txt") == 0 ||
          filename.substr(filename.length() - 3, 3).compare("bin") == 0)) {
       continue;
     }

     if (!use_global && !use_hybrid) {
       use_global = use_hybrid = true;
     }

     if (test_mode) {
       cerr << "Testing: " << filename << endl;
     }

     Ref<LuminanceSource> source;
     try {
       source = ImageReaderSource::create(filename);
     } catch (const zxing::IllegalArgumentException &e) {
       cerr << e.what() << " (ignoring)" << endl;
       continue;
     }

     string expected = read_expected(filename);

     int gresult = 1;
     int hresult = 1;
     if (use_hybrid) {
       hresult = read_image(source, true, expected);
     }
     if (use_global && (verbose || hresult != 0)) {
       gresult = read_image(source, false, expected);
       if (!verbose && gresult != 0) {
         cout << "decoding failed" << endl;
       }
     }
     gresult = gresult == 0;
     hresult = hresult == 0;
     gonly += gresult && !hresult;
     honly += hresult && !gresult;
     both += gresult && hresult;
     neither += !gresult && !hresult;
     total = total + 1;
   }

   if (test_mode) {
     cout << endl
          << "Summary:" << endl
          << " " << total << " images tested total," << endl
          << " " << (honly + both)  << " passed hybrid, " << (gonly + both)
          << " passed global, " << both << " pass both, " << endl
          << " " << honly << " passed only hybrid, " << gonly
          << " passed only global, " << neither << " pass neither." << endl;
   }

   return 0;
 }
	// -- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 --
	/*
	* Copyright 2010-2011 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.
	*/

	#include <iostream>
	#include <fstream>
	#include <string>
	#include "ImageReaderSource.h"
	#include <zxing/common/Counted.h>
	#include <zxing/Binarizer.h>
	#include <zxing/MultiFormatReader.h>
	#include <zxing/Result.h>
	#include <zxing/ReaderException.h>
	#include <zxing/common/GlobalHistogramBinarizer.h>
	#include <zxing/common/HybridBinarizer.h>
	#include <exception>
	#include <zxing/Exception.h>
	#include <zxing/common/IllegalArgumentException.h>
	#include <zxing/BinaryBitmap.h>
	#include <zxing/DecodeHints.h>

	#include <zxing/qrcode/QRCodeReader.h>
	#include <zxing/multi/qrcode/QRCodeMultiReader.h>
	#include <zxing/multi/ByQuadrantReader.h>
	#include <zxing/multi/MultipleBarcodeReader.h>
	#include <zxing/multi/GenericMultipleBarcodeReader.h>

	using namespace std;
	using namespace zxing;
	using namespace zxing::multi;
	using namespace zxing::qrcode;

	namespace {

	bool more = false;
	bool test_mode = false;
	bool try_harder = false;
	bool search_multi = false;
	bool use_hybrid = false;
	bool use_global = false;
	bool verbose = false;

	}

	vector<Ref<Result> > decode(Ref<BinaryBitmap> image, DecodeHints hints) {
	Ref<Reader> reader(new MultiFormatReader);
	return vector<Ref<Result> >(1, reader->decode(image, hints));
	}

	vector<Ref<Result> > decode_multi(Ref<BinaryBitmap> image, DecodeHints hints) {
	MultiFormatReader delegate;
	GenericMultipleBarcodeReader reader(delegate);
	return reader.decodeMultiple(image, hints);
	}

	int read_image(Ref<LuminanceSource> source, bool hybrid, string expected) {
	vector<Ref<Result> > results;
	string cell_result;
	int res = -1;

	try {
	Ref<Binarizer> binarizer;
	if (hybrid) {
	binarizer = new HybridBinarizer(source);
	} else {
	binarizer = new GlobalHistogramBinarizer(source);
	}
	DecodeHints hints(DecodeHints::DEFAULT_HINT);
	hints.setTryHarder(try_harder);
	Ref<BinaryBitmap> binary(new BinaryBitmap(binarizer));
	if (search_multi) {
	results = decode_multi(binary, hints);
	} else {
	results = decode(binary, hints);
	}
	res = 0;
	} catch (const ReaderException& e) {
	cell_result = "zxing::ReaderException: " + string(e.what());
	res = -2;
	} catch (const zxing::IllegalArgumentException& e) {
	cell_result = "zxing::IllegalArgumentException: " + string(e.what());
	res = -3;
	} catch (const zxing::Exception& e) {
	cell_result = "zxing::Exception: " + string(e.what());
	res = -4;
	} catch (const std::exception& e) {
	cell_result = "std::exception: " + string(e.what());
	res = -5;
	}

	if (test_mode && results.size() == 1) {
	std::string result = results[0]->getText()->getText();
	if (expected.empty()) {
	cout << " Expected text or binary data for image missing." << endl
	<< " Detected: " << result << endl;
	res = -6;
	} else {
	if (expected.compare(result) != 0) {
	cout << " Expected: " << expected << endl
	<< " Detected: " << result << endl;
	cell_result = "data did not match";
	res = -6;
	}
	}
	}

	if (res != 0 && (verbose \|\| (use_global ^ use_hybrid))) {
	cout << (hybrid ? "Hybrid" : "Global")
	<< " binarizer failed: " << cell_result << endl;
	} else if (!test_mode) {
	if (verbose) {
	cout << (hybrid ? "Hybrid" : "Global")
	<< " binarizer succeeded: " << endl;
	}
	for (size_t i = 0; i < results.size(); i++) {
	if (more) {
	cout << " Format: "
	<< BarcodeFormat::barcodeFormatNames[results[i]->getBarcodeFormat()]
	<< endl;
	for (int j = 0; j < results[i]->getResultPoints()->size(); j++) {
	cout << " Point[" << j << "]: "
	<< results[i]->getResultPoints()[j]->getX() << " "
	<< results[i]->getResultPoints()[j]->getY() << endl;
	}
	}
	if (verbose) {
	cout << " ";
	}
	cout << results[i]->getText()->getText() << endl;
	}
	}

	return res;
	}

	string read_expected(string imagefilename) {
	string textfilename = imagefilename;
	string::size_type dotpos = textfilename.rfind(".");

	textfilename.replace(dotpos + 1, textfilename.length() - dotpos - 1, "txt");
	ifstream textfile(textfilename.c_str(), ios::binary);
	textfilename.replace(dotpos + 1, textfilename.length() - dotpos - 1, "bin");
	ifstream binfile(textfilename.c_str(), ios::binary);
	ifstream *file = 0;
	if (textfile.is_open()) {
	file = &textfile;
	} else if (binfile.is_open()) {
	file = &binfile;
	} else {
	return std::string();
	}
	file->seekg(0, ios_base::end);
	size_t size = size_t(file->tellg());
	file->seekg(0, ios_base::beg);

	if (size == 0) {
	return std::string();
	}

	char* data = new char[size + 1];
	file->read(data, size);
	data[size] = '\0';
	string expected(data);
	delete[] data;

	return expected;
	}

	int main(int argc, char** argv) {
	if (argc <= 1) {
	cout << "Usage: " << argv[0] << " [OPTION]... <IMAGE>..." << endl
	<< "Read barcodes from each IMAGE file." << endl
	<< endl
	<< "Options:" << endl
	<< " (-h\|--hybrid) use the hybrid binarizer (default)" << endl
	<< " (-g\|--global) use the global binarizer" << endl
	<< " (-v\|--verbose) chattier results printing" << endl
	<< " --more display more information about the barcode" << endl
	<< " --test-mode compare IMAGEs against text files" << endl
	<< " --try-harder spend more time to try to find a barcode" << endl
	<< " --search-multi search for more than one bar code" << endl
	<< endl
	<< "Example usage:" << endl
	<< " zxing --test-mode *.jpg" << endl
	<< endl;
	return 1;
	}

	int total = 0;
	int gonly = 0;
	int honly = 0;
	int both = 0;
	int neither = 0;

	for (int i = 1; i < argc; i++) {
	string filename = argv[i];
	if (filename.compare("--verbose") == 0 \|\|
	filename.compare("-v") == 0) {
	verbose = true;
	continue;
	}
	if (filename.compare("--hybrid") == 0 \|\|
	filename.compare("-h") == 0) {
	use_hybrid = true;
	continue;
	}
	if (filename.compare("--global") == 0 \|\|
	filename.compare("-g") == 0) {
	use_global = true;
	continue;
	}
	if (filename.compare("--more") == 0) {
	more = true;
	continue;
	}
	if (filename.compare("--test-mode") == 0) {
	test_mode = true;
	continue;
	}
	if (filename.compare("--try-harder") == 0) {
	try_harder = true;
	continue;
	}
	if (filename.compare("--search-multi") == 0){
	search_multi = true;
	continue;
	}

	if (filename.length() > 3 &&
	(filename.substr(filename.length() - 3, 3).compare("txt") == 0 \|\|
	filename.substr(filename.length() - 3, 3).compare("bin") == 0)) {
	continue;
	}

	if (!use_global && !use_hybrid) {
	use_global = use_hybrid = true;
	}

	if (test_mode) {
	cerr << "Testing: " << filename << endl;
	}

	Ref<LuminanceSource> source;
	try {
	source = ImageReaderSource::create(filename);
	} catch (const zxing::IllegalArgumentException &e) {
	cerr << e.what() << " (ignoring)" << endl;
	continue;
	}

	string expected = read_expected(filename);

	int gresult = 1;
	int hresult = 1;
	if (use_hybrid) {
	hresult = read_image(source, true, expected);
	}
	if (use_global && (verbose \|\| hresult != 0)) {
	gresult = read_image(source, false, expected);
	if (!verbose && gresult != 0) {
	cout << "decoding failed" << endl;
	}
	}
	gresult = gresult == 0;
	hresult = hresult == 0;
	gonly += gresult && !hresult;
	honly += hresult && !gresult;
	both += gresult && hresult;
	neither += !gresult && !hresult;
	total = total + 1;
	}

	if (test_mode) {
	cout << endl
	<< "Summary:" << endl
	<< " " << total << " images tested total," << endl
	<< " " << (honly + both) << " passed hybrid, " << (gonly + both)
	<< " passed global, " << both << " pass both, " << endl
	<< " " << honly << " passed only hybrid, " << gonly
	<< " passed only global, " << neither << " pass neither." << endl;
	}

	return 0;
	}