// This file is part of OpenCV project. // It is subject to the license terms in the LICENSE file found in the top-level directory // of this distribution and at http://opencv.org/license.html. // // Copyright (C) 2021, Intel Corporation, all rights reserved. #include "precomp.hpp" #include "qrcode_encoder_table.inl.hpp" #include "graphical_code_detector_impl.hpp" namespace cv { using std::vector; const int MAX_PAYLOAD_LEN = 8896; const int MAX_FORMAT_LENGTH = 15; const int MAX_VERSION_LENGTH = 18; const int MODE_BITS_NUM = 4; const uint8_t INVALID_REGION_VALUE = 110; static void decToBin(const int dec_number, const int total_bits, std::vector &bin_number); static uint8_t gfPow(uint8_t x, int power); static uint8_t gfMul(const uint8_t x, const uint8_t y); static uint8_t gfDiv(const uint8_t x, const uint8_t y); static void gfPolyMul(const vector &p, const vector &q, vector &product); static void gfPolyDiv(const vector ÷nd, const vector &divisor, const int ecc_num, vector "ient); static void polyGenerator(const int n, vector &result); static int getBits(const int bits, const vector &payload, int &pay_index); static void decToBin(const int dec_number, const int total_bits, std::vector &bin_number) { for (int i = 0; i < total_bits; i++) { bin_number[total_bits - i - 1] = (dec_number >> i) % 2; } } static void writeDecNumber(const int dec_number, const int total_bits, vector &output_bits) { std::vector bin_number(total_bits); decToBin(dec_number, total_bits, bin_number); output_bits.insert(output_bits.end(), bin_number.begin(), bin_number.end()); } static uint8_t gfPow(uint8_t x, int power) { return gf_exp[(gf_log[x] * power) % 255]; } static uint8_t gfMul(const uint8_t x, const uint8_t y) { if (x == 0 || y == 0) return 0; return gf_exp[(gf_log[x] + gf_log[y]) % 255]; } static uint8_t gfDiv(const uint8_t x, const uint8_t y) { if (x == 0 || y == 0) return 0; return gf_exp[(gf_log[x] + 255 - gf_log[y]) % 255]; } static void gfPolyMul(const vector &p, const vector &q, vector &product) { int len_p = (int)p.size(); int len_q = (int)q.size(); vector temp_result(len_p + len_q - 1, 0); for (int j = 0; j < len_q; j++) { uint8_t q_val = q[j]; if (!q_val) continue; for (int i = 0; i < len_p; i++) { uint8_t p_val = p[i]; if (!p_val) continue; temp_result[i + j] ^= gfMul(p_val, q_val); } } product = temp_result; } static void gfPolyDiv(const vector ÷nd, const vector &divisor, const int bits_needed, vector "ient) { int dividend_len = (int)dividend.size() - 1; int divisor_len = (int)divisor.size() - 1; vector temp = dividend; int times = dividend_len - divisor_len + 1; for (int i = 0; i < times; i++) { uint8_t dividend_val = temp[dividend_len - i]; if(dividend_val != 0) { for (int j = 0; j < divisor_len + 1; j++) { uint8_t divisor_val = divisor[divisor_len - j]; if (divisor_val != 0) { temp[dividend_len - i - j] ^= gfMul(divisor_val, dividend_val); } } } } quotient = vector(temp.begin(), temp.begin() + bits_needed); } static void polyGenerator(const int n, vector &result) { vector temp(2, 1); result = vector(1, 1); for (int i = 1; i <= n; i++) { temp[0] = gfPow(2, i - 1); gfPolyMul(result, temp, result); } } static int getBits(const int bits, const vector &payload, int &pay_index) { int result = 0; for (int i = 0; i < bits; i++) { result = result << 1; result += payload[pay_index++]; } return result; } static int mapSymbol(char c) { if (c >= '0' && c <= '9') return (int)(c - '0'); if (c >= 'A' && c <= 'Z') return (int)(c - 'A') + 10; switch (c) { case ' ': return 36 + 0; case '$': return 36 + 1; case '%': return 36 + 2; case '*': return 36 + 3; case '+': return 36 + 4; case '-': return 36 + 5; case '.': return 36 + 6; case '/': return 36 + 7; case ':': return 36 + 8; } return -1; } static void maskData(const Mat& original, const int mask_type_num, Mat &masked); QRCodeEncoder::QRCodeEncoder() { // nothing } QRCodeEncoder::~QRCodeEncoder() { // nothing } QRCodeEncoder::Params::Params() { version = 0; correction_level = CORRECT_LEVEL_L; mode = MODE_AUTO; structure_number = 1; } class QRCodeEncoderImpl : public QRCodeEncoder { public: QRCodeEncoderImpl(const QRCodeEncoder::Params& parameters) : params(parameters) { version_level = parameters.version; ecc_level = parameters.correction_level; mode_type = parameters.mode; struct_num = parameters.structure_number; version_size = 21; mask_type = 0; parity = 0; sequence_num = 0; total_num = 0; } void encode(const String& encoded_info, OutputArray qrcode) CV_OVERRIDE; void encodeStructuredAppend(const String& input, OutputArrayOfArrays output) CV_OVERRIDE; QRCodeEncoder::Params params; protected: int version_level; CorrectionLevel ecc_level; EncodeMode mode_type; int struct_num; int version_size; int mask_type; vector format; vector version_reserved; vector payload; vector rearranged_data; Mat original; Mat masked_data; uint8_t parity; uint8_t sequence_num; uint8_t total_num; vector final_qrcodes; const VersionInfo* version_info; const BlockParams* cur_ecc_params; bool isNumeric(const std::string& input) const; bool isAlphaNumeric(const std::string& input) const; EncodeMode autoEncodeMode(const std::string &input) const ; bool encodeByte(const std::string& input, vector &output); bool encodeAlpha(const std::string& input, vector &output); bool encodeNumeric(const std::string& input, vector &output); bool encodeECI(const std::string& input, vector &output); bool encodeKanji(const std::string& input, vector &output); bool encodeAuto(const std::string& input, vector &output, EncodeMode *mode = nullptr); bool encodeStructure(const std::string& input, vector &output); int eccLevelToCode(CorrectionLevel level); void padBitStream(); bool stringToBits(const std::string& input_info); void eccGenerate(vector > &data_blocks, vector > &ecc_blocks); void rearrangeBlocks(const vector > &data_blocks, const vector > &ecc_blocks); void writeReservedArea(); bool writeBit(int x, int y, bool value); void writeData(); void structureFinalMessage(); void formatGenerate(const int mask_type_num, vector &format_array); void versionInfoGenerate(const int version_level_num, vector &version_array); void fillReserved(const vector &format_array, Mat &masked); void findAutoMaskType(); bool estimateVersion(const int input_length, EncodeMode mode, vector &possible_version); int versionAuto(const std::string &input_str); int findVersionCapacity(const int input_length, const int ecc, const std::vector& possible_versions); void generatingProcess(const std::string& input, Mat &qrcode); void generateQR(const std::string& input); }; int QRCodeEncoderImpl::eccLevelToCode(CorrectionLevel level) { switch (level) { case CORRECT_LEVEL_L: return 0b01; case CORRECT_LEVEL_M: return 0b00; case CORRECT_LEVEL_Q: return 0b11; case CORRECT_LEVEL_H: return 0b10; } CV_Error( Error::StsBadArg, "Error correction level is incorrect. Available levels are" "CORRECT_LEVEL_L, CORRECT_LEVEL_M, CORRECT_LEVEL_Q, CORRECT_LEVEL_H." ); } int QRCodeEncoderImpl::findVersionCapacity(const int input_length, const int ecc, const std::vector& possible_versions) { int data_codewords, version_index = -1; const int byte_len = 8; version_index = -1; for (int i : possible_versions) { auto& tmp_ecc_params = version_info_database[i].ecc[ecc]; data_codewords = tmp_ecc_params.data_codewords_in_G1 * tmp_ecc_params.num_blocks_in_G1 + tmp_ecc_params.data_codewords_in_G2 * tmp_ecc_params.num_blocks_in_G2; if (data_codewords * byte_len >= input_length) { version_index = i; break; } } return version_index; } static inline int getCapacity(int version, QRCodeEncoder::CorrectionLevel ecc_level, QRCodeEncoder::EncodeMode mode) { const int* capacity = version_capacity_database[version].ec_level[ecc_level].encoding_modes; switch (mode) { case QRCodeEncoder::EncodeMode::MODE_NUMERIC: return capacity[0]; case QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC: return capacity[1]; case QRCodeEncoder::EncodeMode::MODE_BYTE: return capacity[2]; case QRCodeEncoder::EncodeMode::MODE_KANJI: return capacity[3]; default: CV_Error(Error::StsNotImplemented, format("Unexpected mode %d", mode)); } } bool QRCodeEncoderImpl::estimateVersion(const int input_length, EncodeMode mode, vector& possible_version) { possible_version.clear(); CV_Assert(mode != EncodeMode::MODE_AUTO); if (input_length > getCapacity(MAX_VERSION, ecc_level, mode)) { return false; } int version = MAX_VERSION; for (; version > 0; --version) { if (input_length > getCapacity(version, ecc_level, mode)) { break; } } if (version < MAX_VERSION) { version += 1; } possible_version.push_back(version); if (version < MAX_VERSION) { possible_version.push_back(version + 1); } return true; } int QRCodeEncoderImpl::versionAuto(const std::string& input_str) { vector payload_tmp; EncodeMode mode; encodeAuto(input_str, payload_tmp, &mode); vector possible_version; if (!estimateVersion((int)input_str.length(), mode, possible_version)) { return -1; } int nbits = static_cast(payload_tmp.size()); // Extra info for structure's position, total and parity + mode of final message if (mode_type == MODE_STRUCTURED_APPEND) nbits += 4 + 4 + 8 + 4; const auto tmp_version = findVersionCapacity(nbits, ecc_level, possible_version); return tmp_version; } void QRCodeEncoderImpl::generateQR(const std::string &input) { if (struct_num > 1) { for (size_t i = 0; i < input.length(); i++) { parity ^= input[i]; } if (struct_num > 16) { struct_num = 16; } total_num = (uint8_t) struct_num - 1; } auto string_itr = input.begin(); for (int i = struct_num; i > 0; --i) { sequence_num = (uint8_t) (struct_num - i); size_t segment_begin = string_itr - input.begin(); size_t segment_end = (input.end() - string_itr) / i; std::string input_info = input.substr(segment_begin, segment_end); string_itr += segment_end; int detected_version = versionAuto(input_info); int tmp_version_level = version_level; if (detected_version == -1) CV_Error(Error::StsBadArg, "The given input exceeds the maximum capacity of a QR code with the selected encoding mode and error correction level " ); else if (tmp_version_level == 0) tmp_version_level = detected_version; else if (tmp_version_level < detected_version) CV_Error(Error::StsBadArg, "The given version is not suitable for the given input string length "); payload.clear(); payload.reserve(MAX_PAYLOAD_LEN); format = vector (15, 255); version_reserved = vector (18, 255); version_size = (21 + (tmp_version_level - 1) * 4); version_info = &version_info_database[tmp_version_level]; cur_ecc_params = &version_info->ecc[ecc_level]; original = Mat(Size(version_size, version_size), CV_8UC1, Scalar(255)); masked_data = original.clone(); Mat qrcode = masked_data.clone(); generatingProcess(input_info, qrcode); final_qrcodes.push_back(qrcode); } } void QRCodeEncoderImpl::formatGenerate(const int mask_type_num, vector &format_array) { int idx = (eccLevelToCode(ecc_level) << 3) | mask_type_num; format_array.resize(MAX_FORMAT_LENGTH); for (int i = 0; i < MAX_FORMAT_LENGTH; ++i) { format_array[i] = (formatInfoLUT[idx] >> i) & 1; } } void QRCodeEncoderImpl::versionInfoGenerate(const int version_level_num, vector &version_array) { const int version_bits_num = 6; std::vector version_bits(version_bits_num); decToBin(version_level_num, version_bits_num, version_bits); std::reverse(version_bits.begin(), version_bits.end()); vector shift(12, 0); vector polynomial; hconcat(shift, version_bits, polynomial); const int generator_len = 13; const uint8_t generator_arr[generator_len] = {1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1}; std::vector format_mask (generator_arr, generator_arr + sizeof(generator_arr) / sizeof(generator_arr[0])); vector ecc_code; gfPolyDiv(polynomial, format_mask, 12, ecc_code); hconcat(ecc_code, version_bits, version_array); } bool QRCodeEncoderImpl::encodeAlpha(const std::string& input, vector& output) { writeDecNumber(MODE_ALPHANUMERIC, MODE_BITS_NUM, output); int length_bits_num = 13; if (version_level < 10) length_bits_num = 9; else if (version_level < 27) length_bits_num = 11; int str_len = int(input.length()); writeDecNumber(str_len, length_bits_num, output); const int alpha_symbol_bits = 11; const int residual_bits = 6; for (int i = 0; i < str_len - 1; i += 2) { int index_1 = mapSymbol(input[i]); int index_2 = mapSymbol(input[i + 1]); if(index_1 == -1 || (index_2 == -1 && i + 1 < str_len)) return false; int alpha = index_1 * 45 + index_2; writeDecNumber(alpha, alpha_symbol_bits, output); } if (str_len % 2 != 0) { int index_residual_elem = mapSymbol(*input.rbegin()); if(index_residual_elem == -1) return false; writeDecNumber(index_residual_elem, residual_bits, output); } return true; } bool QRCodeEncoderImpl::encodeByte(const std::string& input, vector& output) { writeDecNumber(MODE_BYTE, MODE_BITS_NUM, output); int length_bits_num = 8; if (version_level > 9) length_bits_num = 16; int str_len = int(input.length()); writeDecNumber(str_len, length_bits_num, output); const int byte_symbol_bits = 8; for (int i = 0; i < str_len; i++) { writeDecNumber(uint8_t(input[i]), byte_symbol_bits, output); } return true; } bool QRCodeEncoderImpl::encodeNumeric(const std::string& input,vector& output) { writeDecNumber(MODE_NUMERIC, MODE_BITS_NUM, output); int length_bits_num = 10; if (version_level >= 27) length_bits_num = 14; else if (version_level >= 10) length_bits_num = 12; int str_len = int(input.length()); writeDecNumber(str_len, length_bits_num, output); int count = 0; const int num_symbol_bits = 10; const int residual_bits[2] = {7, 4}; while (count + 3 <= str_len) { if (input[count] > '9' || input[count] < '0' || input[count + 1] > '9' || input[count + 1] < '0' || input[count + 2] > '9' || input[count + 2] < '0') return false; int num = 100 * (int)(input[count] - '0') + 10 * (int)(input[count + 1] - '0') + (int)(input[count + 2] - '0'); writeDecNumber(num, num_symbol_bits, output); count += 3; } if (count + 2 == str_len) { if (input[count] > '9' || input[count] < '0'|| input[count + 1] >'9'|| input[count + 1] < '0') return false; int num = 10 * (int)(input[count] - '0') + (int)(input[count + 1] - '0'); writeDecNumber(num, residual_bits[0], output); } else if (count + 1 == str_len) { if (input[count] > '9' || input[count] < '0') return false; int num = (int)(input[count] - '0'); writeDecNumber(num, residual_bits[1], output); } return true; } bool QRCodeEncoderImpl::encodeECI(const std::string& input, vector& output) { writeDecNumber(MODE_ECI, MODE_BITS_NUM, output); const uint32_t assign_value_range[3] = {127, 16383, 999999}; // by adding other ECI modes `eci_assignment_number` can be moved to algorithm parameters uint32_t eci_assignment_number = ECI_UTF8; // utf-8 int codewords = 1; if(eci_assignment_number > assign_value_range[2]) return false; if (eci_assignment_number > assign_value_range[1]) codewords = 3; else if (eci_assignment_number > assign_value_range[0]) codewords = 2; const int bits = 8; switch (codewords) { case 1: writeDecNumber(0, codewords, output); writeDecNumber(eci_assignment_number, codewords * bits - 1, output); break; case 2: writeDecNumber(2, codewords, output); writeDecNumber(eci_assignment_number, codewords * bits - 2, output); break; case 3: writeDecNumber(6, codewords, output); writeDecNumber(eci_assignment_number, codewords * bits - 3, output); break; } encodeByte(input, output); return true; } bool QRCodeEncoderImpl::encodeKanji(const std::string& input, vector& output) { writeDecNumber(MODE_KANJI, MODE_BITS_NUM, output); int length_bits_num = 8; if (version_level >= 10) length_bits_num = 10; else if (version_level >= 27) length_bits_num = 12; int str_len = int(input.length()) / 2; writeDecNumber(str_len, length_bits_num, output); const int kanji_symbol_bits = 13; int i = 0; while(i < str_len * 2) { uint16_t high_byte = (uint16_t)(input[i] & 0xff); uint16_t low_byte = (uint16_t)(input[i+1] & 0xff); uint16_t per_char = (high_byte << 8) + (low_byte); if(0x8140 <= per_char && per_char <= 0x9FFC) { per_char -= 0x8140; } else if(0xE040 <= per_char && per_char <= 0xEBBF) { per_char -= 0xC140; } uint16_t new_high = per_char >> 8; uint16_t result = new_high * 0xC0; result += (per_char & 0xFF); writeDecNumber(result, kanji_symbol_bits, output); i += 2; } return true; } bool QRCodeEncoderImpl::encodeStructure(const std::string& input, vector& output) { const int num_field = 4; const int checksum_field = 8; writeDecNumber(MODE_STRUCTURED_APPEND, MODE_BITS_NUM, output); writeDecNumber(sequence_num, num_field, output); writeDecNumber(total_num, num_field, output); writeDecNumber(parity, checksum_field, output); return encodeAuto(input, output); } bool QRCodeEncoderImpl::isNumeric(const std::string& input) const { for (size_t i = 0; i < input.length(); i++) { if (input[i] < '0' || input[i] > '9') return false; } return true; } bool QRCodeEncoderImpl::isAlphaNumeric(const std::string& input) const { for (size_t i = 0; i < input.length(); i++) { if (mapSymbol(input[i]) == -1) return false; } return true; } QRCodeEncoder::EncodeMode QRCodeEncoderImpl::autoEncodeMode(const std::string &input) const { if (isNumeric(input)) { return EncodeMode::MODE_NUMERIC; } if (isAlphaNumeric(input)) { return EncodeMode::MODE_ALPHANUMERIC; } return EncodeMode::MODE_BYTE; } bool QRCodeEncoderImpl::encodeAuto(const std::string& input, vector& output, EncodeMode *mode) { const auto selected_mode = autoEncodeMode(input); CV_Assert(selected_mode != EncodeMode::MODE_AUTO); switch (selected_mode) { case EncodeMode::MODE_NUMERIC: encodeNumeric(input, output); break; case EncodeMode::MODE_ALPHANUMERIC: encodeAlpha(input, output); break; case EncodeMode::MODE_STRUCTURED_APPEND: encodeByte(input, output); break; case EncodeMode::MODE_BYTE: encodeByte(input, output); break; case EncodeMode::MODE_KANJI: encodeKanji(input, output); break; case EncodeMode::MODE_ECI: encodeECI(input, output); break; default: break; } if (mode != nullptr) { *mode = selected_mode; } return true; } void QRCodeEncoderImpl::padBitStream() { int total_data = version_info->total_codewords - cur_ecc_params->ecc_codewords * (cur_ecc_params->num_blocks_in_G1 + cur_ecc_params->num_blocks_in_G2); const int bits = 8; total_data *= bits; int pad_num = total_data - (int)payload.size(); if (pad_num <= 0) return; else if (pad_num <= 4) { int payload_size = (int)payload.size(); writeDecNumber(0, payload_size, payload); } else { writeDecNumber(0, 4, payload); int i = payload.size() % bits; if (i != 0) { writeDecNumber(0, bits - i, payload); } pad_num = total_data - (int)payload.size(); if (pad_num > 0) { const int pad_patterns[2] = {236, 17}; int num = pad_num / bits; const int pattern_size = 8; for (int j = 0; j < num; j++) { writeDecNumber(pad_patterns[j % 2], pattern_size, payload); } } } } bool QRCodeEncoderImpl::stringToBits(const std::string& input_info) { switch (mode_type) { case MODE_NUMERIC: return encodeNumeric(input_info, payload); case MODE_ALPHANUMERIC: return encodeAlpha(input_info, payload); case MODE_STRUCTURED_APPEND: return encodeStructure(input_info, payload); case MODE_BYTE: return encodeByte(input_info, payload); case MODE_ECI: return encodeECI(input_info, payload); case MODE_KANJI: return encodeKanji(input_info, payload); default: return encodeAuto(input_info, payload); } } void QRCodeEncoderImpl::eccGenerate(vector > &data_blocks, vector > &ecc_blocks) { const int ec_codewords = cur_ecc_params->ecc_codewords; int pay_index = 0; vector g_x; polyGenerator(ec_codewords, g_x); int blocks = cur_ecc_params->num_blocks_in_G2 + cur_ecc_params->num_blocks_in_G1; for (int i = 0; i < blocks; i++) { int block_len = 0; if (i < cur_ecc_params->num_blocks_in_G1) { block_len = cur_ecc_params->data_codewords_in_G1; } else { block_len = cur_ecc_params->data_codewords_in_G2; } vector block_i (block_len, 0); for (int j = 0; j < block_len; j++) { block_i[block_len - 1 - j] = (uchar)getBits(8, payload, pay_index); } vector dividend; vector shift (ec_codewords, 0); hconcat(shift, block_i, dividend); vector ecc_i; gfPolyDiv(dividend, g_x, ec_codewords, ecc_i); data_blocks.push_back(block_i); ecc_blocks.push_back(ecc_i); } } void QRCodeEncoderImpl::rearrangeBlocks(const vector > &data_blocks, const vector > &ecc_blocks) { rearranged_data.clear(); int blocks = cur_ecc_params->num_blocks_in_G2 + cur_ecc_params->num_blocks_in_G1; int col_border = max(cur_ecc_params->data_codewords_in_G2, cur_ecc_params->data_codewords_in_G1); int total_codeword_num = version_info->total_codewords; int is_not_equal = cur_ecc_params->data_codewords_in_G2 - cur_ecc_params->data_codewords_in_G1; int add_steps = cur_ecc_params->data_codewords_in_G2 > cur_ecc_params->data_codewords_in_G1 ? (cur_ecc_params->data_codewords_in_G2 - cur_ecc_params->data_codewords_in_G1) * cur_ecc_params->num_blocks_in_G1 : 0; rearranged_data.reserve(total_codeword_num + add_steps); for (int i = 0; i < total_codeword_num + add_steps; i++) { int cur_col = i / blocks; int cur_row = i % blocks; int data_col = (int)data_blocks[cur_row].size() - 1; int ecc_col = (int)ecc_blocks[cur_row].size() - 1; uint8_t tmp = 0; if (cur_col < col_border) { if (is_not_equal && cur_col == cur_ecc_params->data_codewords_in_G2 - 1 && cur_row < cur_ecc_params->num_blocks_in_G1) { continue; } else { tmp = data_blocks[cur_row][data_col - cur_col]; } } else { int index = ecc_col - (cur_col - col_border); tmp = ecc_blocks[cur_row][index]; } rearranged_data.push_back(tmp); } } void QRCodeEncoderImpl::findAutoMaskType() { int best_index = 0; int lowest_penalty = INT_MAX; int penalty_two_value = 3, penalty_three_value = 40; for (int cur_type = 0; cur_type < 8; cur_type++) { Mat test_result = masked_data.clone(); vector test_format = format; maskData(original, cur_type, test_result); formatGenerate(cur_type, test_format); fillReserved(test_format, test_result); int continued_num = 0; int penalty_one = 0, penalty_two = 0, penalty_three = 0, penalty_four = 0, penalty_total = 0; int current_color = -1; for (int direction = 0; direction < 2; direction++) { if (direction != 0) { test_result = test_result.t(); } for (int i = 0; i < version_size; i++) { int per_row = 0; for (int j = 0; j < version_size; j++) { if (j == 0) { current_color = test_result.at(i, j); continued_num = 1; continue; } if (current_color == test_result.at(i, j)) { continued_num += 1; } if (current_color != test_result.at(i, j) || j + 1 == version_size) { current_color = test_result.at(i, j); if (continued_num >= 5) { per_row += 3 + continued_num - 5; } continued_num = 1; } } penalty_one += per_row; } } for (int i = 0; i < version_size - 1; i++) { for (int j = 0; j < version_size - 1; j++) { uint8_t color = test_result.at(i, j); if (color == test_result.at(i, j + 1) && color == test_result.at(i + 1, j + 1) && color == test_result.at(i + 1, j)) { penalty_two += penalty_two_value; } } } Mat penalty_pattern[2]; penalty_pattern[0] = (Mat_(1, 11) << 255, 255, 255, 255, 0, 255, 0, 0, 0, 255, 0); penalty_pattern[1] = (Mat_(1, 11) << 0, 255, 0, 0, 0, 255, 0, 255, 255, 255, 255); for (int direction = 0; direction < 2; direction++) { if (direction != 0) { test_result = test_result.t(); } for (int i = 0; i < version_size; i++) { int per_row = 0; for (int j = 0; j < version_size - 10; j++) { Mat cur_test = test_result(Range(i, i + 1), Range(j, j + 11)); for (int pattern_index = 0; pattern_index < 2; pattern_index++) { Mat diff = (penalty_pattern[pattern_index] != cur_test); bool equal = (countNonZero(diff) == 0); if (equal) { per_row += penalty_three_value; } } } penalty_three += per_row; } } int dark_modules = 0; int total_modules = 0; for (int i = 0; i < version_size; i++) { for (int j = 0; j < version_size; j++) { if (test_result.at(i, j) == 0) { dark_modules += 1; } total_modules += 1; } } if (total_modules == 0) continue; // TODO: refactor, extract functions to reduce complexity int modules_percent = dark_modules * 100 / total_modules; int lower_bound = 45; int upper_bound = 55; int diff = min(abs(modules_percent - lower_bound), abs(modules_percent - upper_bound)); penalty_four = (diff / 5) * 10; penalty_total = penalty_one + penalty_two + penalty_three + penalty_four; if (penalty_total < lowest_penalty) { best_index = cur_type; lowest_penalty = penalty_total; } } mask_type = best_index; } void maskData(const Mat& original, const int mask_type_num, Mat& masked) { int version_size = original.rows; for (int i = 0; i < version_size; i++) { for (int j = 0; j < version_size; j++) { if (original.at(i, j) == INVALID_REGION_VALUE) { continue; } else if((mask_type_num == 0 && !((i + j) % 2)) || (mask_type_num == 1 && !(i % 2)) || (mask_type_num == 2 && !(j % 3)) || (mask_type_num == 3 && !((i + j) % 3)) || (mask_type_num == 4 && !(((i / 2) + (j / 3)) % 2)) || (mask_type_num == 5 && !((i * j) % 2 + (i * j) % 3))|| (mask_type_num == 6 && !(((i * j) % 2 + (i * j) % 3) % 2))|| ((mask_type_num == 7 && !(((i * j) % 3 + (i + j) % 2) % 2)))) { masked.at(i, j) = original.at(i, j) ^ 255; } } } } void QRCodeEncoderImpl::writeReservedArea() { vector finder_pattern(3); finder_pattern[0] = Rect(Point(0, 0), Point(9, 9)); finder_pattern[1] = Rect(Point(0, (unsigned)version_size - 8), Point(9, version_size)); finder_pattern[2] = Rect(Point((unsigned)version_size - 8, 0), Point(version_size, 9)); const int coordinates_num = 2; int locator_position[coordinates_num] = {3, version_size - 1 - 3}; for (int first_coordinate = 0; first_coordinate < coordinates_num; first_coordinate++) { for (int second_coordinate = 0; second_coordinate < coordinates_num; second_coordinate++) { if (first_coordinate == 1 && second_coordinate == 1) { continue; } int x = locator_position[first_coordinate]; int y = locator_position[second_coordinate]; for (int i = -5; i <= 5; i++) { for (int j = -5; j <= 5; j++) { if (x + i < 0 || x + i >= version_size || y + j < 0 || y + j >= version_size) { continue; } if (!(abs(j) == 2 && abs(i) <= 2) && !(abs(j) <= 2 && abs(i) == 2) && !(abs(i) == 4) && !(abs(j) == 4)) { masked_data.at(x + i, y + j) = 0; } if ((y == locator_position[1] && j == -5) || (x == locator_position[1] && i == -5)) { continue; } else { original.at(x + i, y + j) = INVALID_REGION_VALUE; } } } } } int x = locator_position[1] - 4; int y = locator_position[0] + 5; masked_data.at(x, y) = 0; original.at(x, y) = INVALID_REGION_VALUE; if (version_level >= 7) { for (int i = 0; i <= 5; i++) { for (int j = version_size - 11; j <= version_size - 8; j++) { original.at(i, j) = INVALID_REGION_VALUE; original.at(j, i) = INVALID_REGION_VALUE; } } } for (int i = 0; i < version_size; i++) { for (int j = 0; j < version_size; j++) { if (original.at(i, j) == INVALID_REGION_VALUE) { continue; } if ((i == 6 || j == 6)) { original.at(i, j) = INVALID_REGION_VALUE; if (!((i == 6) && (j - 7) % 2 == 0) && !((j == 6) && ((i - 7) % 2 == 0))) { masked_data.at(i, j) = 0; } } } } for (int first_coord = 0; first_coord < MAX_ALIGNMENT && version_info->alignment_pattern[first_coord]; first_coord++) { for (int second_coord = 0; second_coord < MAX_ALIGNMENT && version_info->alignment_pattern[second_coord]; second_coord++) { x = version_info->alignment_pattern[first_coord]; y = version_info->alignment_pattern[second_coord]; bool is_in_finder = false; for (size_t i = 0; i < finder_pattern.size(); i++) { Rect rect = finder_pattern[i]; if (x >= rect.tl().x && x <= rect.br().x && y >= rect.tl().y && y <= rect.br().y) { is_in_finder = true; break; } } if (!is_in_finder) { for (int i = -2; i <= 2; i++) { for (int j = -2; j <= 2; j++) { original.at(x + i, y + j) = INVALID_REGION_VALUE; if ((j == 0 && i == 0) || (abs(j) == 2) || abs(i) == 2) { masked_data.at(x + i, y + j) = 0; } } } } } } } bool QRCodeEncoderImpl::writeBit(int x, int y, bool value) { if (original.at(y, x) == INVALID_REGION_VALUE) { return false; } if (!value) { original.at(y, x) = 0; masked_data.at(y, x) = 0; } original.at(y, x) = static_cast(255 * value); masked_data.at(y, x) = static_cast(255 * value); return true; } void QRCodeEncoderImpl::writeData() { int y = version_size - 1; int x = version_size - 1; int dir = -1; int count = 0; int codeword_value = rearranged_data[0]; const int limit_bits = (int)rearranged_data.size() * 8; bool limit_reached = false; while (x > 0) { if (x == 6) { x --; } for(int i = 0; i <= 1; i++) { bool bit_value = (codeword_value & (0x80 >> count % 8)) == 0; bool success = writeBit(x - i, y, bit_value); if (!success) { continue; } count++; if (count == limit_bits) { limit_reached = true; break; } if (count % 8 == 0) { codeword_value = rearranged_data[count / 8]; } } if (limit_reached) { break; } y += dir; if (y < 0 || y >= version_size) { dir = -dir; x -= 2; y += dir; } } } void QRCodeEncoderImpl::fillReserved(const vector &format_array, Mat &masked) { for (int i = 0; i < 7; i++) { if (format_array[MAX_FORMAT_LENGTH - 1 - i] == 0) { masked.at(version_size - 1 - i, 8) = 255; } else { masked.at(version_size - 1 - i, 8) = 0; } } for (int i = 0; i < 8; i++) { if (format_array[MAX_FORMAT_LENGTH - 1 - (7 + i)] == 0) { masked.at(8, version_size - 8 + i) = 255; } else { masked.at(8, version_size - 8 + i) = 0; } } static const int xs_format[MAX_FORMAT_LENGTH] = { 8, 8, 8, 8, 8, 8, 8, 8, 7, 5, 4, 3, 2, 1, 0 }; static const int ys_format[MAX_FORMAT_LENGTH] = { 0, 1, 2, 3, 4, 5, 7, 8, 8, 8, 8, 8, 8, 8, 8 }; for (int i = MAX_FORMAT_LENGTH - 1; i >= 0; i--) { if (format_array[i] == 0) { masked.at(ys_format[i], xs_format[i]) = 255; } else { masked.at(ys_format[i], xs_format[i]) = 0; } } if (version_level >= 7) { const int max_size = version_size; const int version_block_width = 2; const int xs_version[version_block_width][MAX_VERSION_LENGTH] = { { 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0 }, { max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11 } }; const int ys_version[version_block_width][MAX_VERSION_LENGTH] = { { max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11, max_size - 9, max_size - 10, max_size - 11 }, { 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0, } }; for (int i = 0; i < version_block_width; i++) { for (int j = 0; j < MAX_VERSION_LENGTH; j++) { if (version_reserved[MAX_VERSION_LENGTH - j - 1] == 0) { masked.at(ys_version[i][j], xs_version[i][j]) = 255; } else { masked.at(ys_version[i][j], xs_version[i][j]) = 0; } } } } } void QRCodeEncoderImpl::structureFinalMessage() { writeReservedArea(); writeData(); findAutoMaskType(); maskData(original, mask_type, masked_data); formatGenerate(mask_type, format); versionInfoGenerate(version_level, version_reserved); fillReserved(format, masked_data); } void QRCodeEncoderImpl::generatingProcess(const std::string& input, Mat& final_result) { vector > data_blocks, ecc_blocks; if (!stringToBits(input)) { return; } padBitStream(); eccGenerate(data_blocks, ecc_blocks); rearrangeBlocks(data_blocks, ecc_blocks); structureFinalMessage(); final_result = masked_data.clone(); const int border = 2; copyMakeBorder(final_result, final_result, border, border, border, border, BORDER_CONSTANT, Scalar(255)); } void QRCodeEncoderImpl::encode(const String& input, OutputArray output) { if (output.kind() != _InputArray::MAT) CV_Error(Error::StsBadArg, "Output should be cv::Mat"); CV_Check((int)mode_type, mode_type != MODE_STRUCTURED_APPEND, "For structured append mode please call encodeStructuredAppend() method"); CV_Check(struct_num, struct_num == 1, "For structured append mode please call encodeStructuredAppend() method"); generateQR(input); CV_Assert(!final_qrcodes.empty()); output.assign(final_qrcodes[0]); final_qrcodes.clear(); } void QRCodeEncoderImpl::encodeStructuredAppend(const String& input, OutputArrayOfArrays output) { if (output.kind() != _InputArray::STD_VECTOR_MAT) CV_Error(Error::StsBadArg, "Output should be vector of cv::Mat"); mode_type = MODE_STRUCTURED_APPEND; generateQR(input); CV_Assert(!final_qrcodes.empty()); output.create((int)final_qrcodes.size(), 1, final_qrcodes[0].type()); vector dst; output.getMatVector(dst); for (int i = 0; i < (int)final_qrcodes.size(); i++) { output.getMatRef(i) = final_qrcodes[i]; } final_qrcodes.clear(); } Ptr QRCodeEncoder::create(const QRCodeEncoder::Params& parameters) { return makePtr(parameters); } class QRCodeDecoderImpl : public QRCodeDecoder { public: bool decode(const Mat& straight, String& decoded_info) CV_OVERRIDE; private: QRCodeEncoder::CorrectionLevel level; int version; struct Bitstream { int next(int bits) { CV_Assert(idx < data.size()); int val = 0; while (bits >= actualBits) { val |= data[idx++] << (bits - actualBits); bits -= actualBits; actualBits = 8; } if (bits) { val |= data[idx] >> (actualBits - bits); actualBits -= bits; data[idx] &= 255 >> (8 - actualBits); } return val; } bool empty() { return idx >= data.size(); } std::vector data; int actualBits = 8; size_t idx = 0; } bitstream; bool run(const Mat& straight, String& decoded_info); bool decodeFormatInfo(const Mat& straight, int& mask); bool correctFormatInfo(uint16_t& format_info); void extractCodewords(Mat& source, std::vector& codewords); bool errorCorrection(std::vector& codewords); bool errorCorrectionBlock(std::vector& codewords); void decodeSymbols(String& result); void decodeNumeric(String& result); void decodeAlpha(String& result); void decodeByte(String& result); void decodeECI(String& result); void decodeKanji(String& result); void decodeStructuredAppend(String& result); }; QRCodeDecoder::~QRCodeDecoder() { // nothing } Ptr QRCodeDecoder::create() { return makePtr(); } bool QRCodeDecoderImpl::decode(const Mat& _straight, String& decoded_info) { Mat straight = ~_straight; // Invert modules bool decoded = run(straight, decoded_info); if (!decoded) { cv::transpose(straight, straight); decoded = run(straight, decoded_info); } return decoded; } // Unmask format info bits and apply error correction bool QRCodeDecoderImpl::correctFormatInfo(uint16_t& format_info) { static const uint16_t mask_pattern = 0b101010000010010; cv::Hamming hd; for (int i = 0; i < 32; ++i) { // Compute Hamming distance int distance = hd(reinterpret_cast(&formatInfoLUT[i]), reinterpret_cast(&format_info), 2); // Up to 3 bit errors might be corrected. // So if distance is less or equal than 3 - we found a correct format info. if (distance <= 3) { format_info = formatInfoLUT[i] ^ mask_pattern; return true; } } return false; } bool QRCodeDecoderImpl::decodeFormatInfo(const Mat& straight, int& mask) { // Read left-top format info uint16_t format_info = 0; for (int i = 0; i < 6; ++i) format_info |= (straight.at(i, 8) & 1) << i; format_info |= (straight.at(7, 8) & 1) << 6; format_info |= (straight.at(8, 8) & 1) << 7; format_info |= (straight.at(8, 7) & 1) << 8; for (int i = 9; i < 15; ++i) format_info |= (straight.at(8, 14 - i) & 1) << i; bool correct = correctFormatInfo(format_info); // Format information 15bit sequence appears twice. // Try extract format info from different position. uint16_t format_info_dup = 0; for (int i = 0; i < 8; ++i) format_info_dup |= (straight.at(8, straight.cols - 1 - i) & 1) << i; for (int i = 0; i < 7; ++i) format_info_dup |= (straight.at(straight.rows - 7 + i, 8) & 1) << (i + 8); if (correctFormatInfo(format_info_dup)) { // Both strings must be the same if (correct && format_info != format_info_dup) return false; format_info = format_info_dup; } else { if (!correct) return false; } switch((format_info >> 13) & 0b11) { case 0: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_M; break; case 1: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_L; break; case 2: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_H; break; case 3: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_Q; break; }; mask = (format_info >> 10) & 0b111; return true; } bool QRCodeDecoderImpl::run(const Mat& straight, String& decoded_info) { CV_Assert(straight.rows == straight.cols); version = (straight.rows - 21) / 4 + 1; decoded_info = ""; mode = static_cast(0); eci = static_cast(0); // Decode format info int maskPattern; bool decoded = decodeFormatInfo(straight, maskPattern); if (!decoded) { return false; } // Generate data mask Mat masked = straight.clone(); maskData(straight, maskPattern, masked); extractCodewords(masked, bitstream.data); if (!errorCorrection(bitstream.data)) { return false; } decodeSymbols(decoded_info); return true; } bool QRCodeDecoderImpl::errorCorrection(std::vector& codewords) { CV_CheckEQ((int)codewords.size(), version_info_database[version].total_codewords, "Number of codewords"); int numBlocks = version_info_database[version].ecc[level].num_blocks_in_G1 + version_info_database[version].ecc[level].num_blocks_in_G2; if (numBlocks == 1) { return errorCorrectionBlock(codewords); } size_t numData = 0; std::vector blockSizes; blockSizes.reserve(numBlocks); for (int i = 0; i < version_info_database[version].ecc[level].num_blocks_in_G1; ++i) { blockSizes.push_back(version_info_database[version].ecc[level].data_codewords_in_G1); numData += blockSizes.back(); } for (int i = 0; i < version_info_database[version].ecc[level].num_blocks_in_G2; ++i) { blockSizes.push_back(version_info_database[version].ecc[level].data_codewords_in_G2); numData += blockSizes.back(); } // TODO: parallel_for std::vector> blocks(numBlocks); int minBlockSize = *std::min_element(blockSizes.begin(), blockSizes.end()); size_t offset = 0; for (int i = 0; i < minBlockSize; ++i) { for (int j = 0; j < numBlocks; ++j) { blocks[j].push_back(codewords[offset++]); } } // Put remaining data codewords for (int j = 0; j < numBlocks; ++j) { CV_Assert(blockSizes[j] == minBlockSize || blockSizes[j] == minBlockSize + 1); if (blockSizes[j] > minBlockSize) blocks[j].push_back(codewords[offset++]); } // Copy error correction codewords int numEcc = version_info_database[version].ecc[level].ecc_codewords; for (int i = 0; i < numEcc; ++i) { for (int j = 0; j < numBlocks; ++j) { blocks[j].push_back(codewords[offset++]); } } parallel_for_(Range(0, numBlocks), [&](const Range& r) { for (int i = r.start; i < r.end; ++i) { if (!errorCorrectionBlock(blocks[i])) { blocks[i].clear(); return; } } }); // Collect blocks back after error correction. Trim error correction codewords. codewords.resize(numData); offset = 0; for (size_t i = 0; i < blocks.size(); ++i) { if (blocks[i].empty()) return false; std::copy(blocks[i].begin(), blocks[i].end(), codewords.begin() + offset); offset += blocks[i].size(); } return true; } bool QRCodeDecoderImpl::errorCorrectionBlock(std::vector& codewords) { size_t numEcc = version_info_database[version].ecc[level].ecc_codewords; size_t numSyndromes = numEcc; // According to the ISO there is a formula for a number of the syndromes. // However several tests don't pass the error correction step because of less number of syndromes: // 1M: qrcodes/detection/lots/image001.jpg from BoofCV (8 syndromes by formula, 10 needed) // 1L: Objdetect_QRCode_Multi.regression/13 (4 syndromes by formula, 6 needed) // 2L: qrcodes/detection/brightness/image011.jpg from BoofCV (8 syndromes by formula, 10 needed) if (numSyndromes % 2 == 1) numSyndromes -= 1; // Compute syndromes bool hasError = false; std::vector syndromes(numSyndromes, codewords[0]); for (size_t i = 0; i < syndromes.size(); ++i) { for (size_t j = 1; j < codewords.size(); ++j) { syndromes[i] = gfMul(syndromes[i], gfPow(2, static_cast(i))) ^ codewords[j]; } hasError |= syndromes[i] != 0; } if (!hasError) { // Trim error correction codewords codewords.resize(codewords.size() - numEcc); return true; } // Run Berlekamp–Massey algorithm to find error positions (coefficients of locator poly) size_t L = 0; // number of assumed errors size_t m = 1; // shift value (between C and B) uint8_t b = 1; // discrepancy from last L update std::vector C(numSyndromes, 0); // Error locator polynomial std::vector B(numSyndromes, 0); // A copy of error locator from previos L update C[0] = B[0] = 1; for (size_t i = 0; i < numSyndromes; ++i) { CV_Assert(m + L - 1 < C.size()); // m >= 1 on any iteration uint8_t discrepancy = syndromes[i]; for (size_t j = 1; j <= L; ++j) { discrepancy ^= gfMul(C[j], syndromes[i - j]); } if (discrepancy == 0) { m += 1; } else { std::vector C_copy = C; uint8_t inv_b = gfDiv(1, b); uint8_t tmp = gfMul(discrepancy, inv_b); for (size_t j = 0; j < L; ++j) { C[m + j] ^= gfMul(tmp, B[j]); } if (2 * L <= i) { L = i + 1 - L; B = C_copy; b = discrepancy; m = 1; } else { m += 1; } } } // There is an error at i-th position if i is a root of locator poly std::vector errLocs; errLocs.reserve(L); for (size_t i = 0; i < codewords.size(); ++i) { uint8_t val = 1; uint8_t pos = gfPow(2, static_cast(i)); for (size_t j = 1; j <= L; ++j) { val = gfMul(val, pos) ^ C[j]; } if (val == 0) { errLocs.push_back(static_cast(codewords.size() - 1 - i)); } } // Number of assumed errors does not match number of error locations if (errLocs.size() != L) return false; // Forney algorithm for error correction using syndromes and known error locations std::vector errEval; gfPolyMul(C, syndromes, errEval); for (size_t i = 0; i < errLocs.size(); ++i) { uint8_t numenator = 0, denominator = 0; uint8_t X = gfPow(2, static_cast(codewords.size() - 1 - errLocs[i])); uint8_t inv_X = gfDiv(1, X); for (size_t j = 0; j < L; ++j) { numenator = gfMul(numenator, inv_X) ^ errEval[L - 1 - j]; } // Compute demoninator as a product of (1-X_i * X_k) for i != k // TODO: optimize, there is a dubplicated compute denominator = 1; for (size_t j = 0; j < errLocs.size(); ++j) { if (i == j) continue; uint8_t Xj = gfPow(2, static_cast(codewords.size() - 1 - errLocs[j])); denominator = gfMul(denominator, 1 ^ gfMul(inv_X, Xj)); } uint8_t errValue = gfDiv(numenator, denominator); codewords[errLocs[i]] ^= errValue; } // Trim error correction codewords codewords.resize(codewords.size() - numEcc); return true; } void QRCodeDecoderImpl::extractCodewords(Mat& source, std::vector& codewords) { const VersionInfo& version_info = version_info_database[version]; // Mask alignment markers std::vector alignCenters; alignCenters.reserve(MAX_ALIGNMENT); for (int i = 0; i < MAX_ALIGNMENT && version_info.alignment_pattern[i]; i++) alignCenters.push_back(version_info.alignment_pattern[i]); for (size_t i = 0; i < alignCenters.size(); i++) { for (size_t j = 0; j < alignCenters.size(); j++) { if ((i == alignCenters.size() - 1 && j == 0) || (i == 0 && j == 0) || (j == alignCenters.size() - 1 && i == 0)) continue; int x = alignCenters[i]; int y = alignCenters[j]; Mat area = source({x - 2, x + 3}, {y - 2, y + 3}); area.setTo(INVALID_REGION_VALUE); } } // Mask detection markers source.rowRange(0, 9).colRange(source.cols - 8, source.cols).setTo(INVALID_REGION_VALUE); source.rowRange(0, 9).colRange(0, 9).setTo(INVALID_REGION_VALUE); source.colRange(0, 9).rowRange(source.rows - 8, source.rows).setTo(INVALID_REGION_VALUE); // Mask Version Information blocks if (version >= 7) { source.rowRange(0, 6).colRange(source.cols - 12, source.cols - 9).setTo(INVALID_REGION_VALUE); source.colRange(0, 6).rowRange(source.rows - 12, source.rows - 9).setTo(INVALID_REGION_VALUE); } // Mask timing pattern source.row(6) = INVALID_REGION_VALUE; std::vector bits; bits.reserve(source.total() - source.cols); bool moveUpwards = true; for (auto& data : {source.colRange(7, source.cols), source.colRange(0, 6)}) { for (int i = data.cols / 2 - 1; i >= 0; --i) { Mat col0 = data.col(i * 2); Mat col1 = data.col(i * 2 + 1); for (int j = 0; j < data.rows; ++j) { if (moveUpwards) { bits.push_back(col1.at(data.rows - 1 - j)); bits.push_back(col0.at(data.rows - 1 - j)); } else { bits.push_back(col1.at(j)); bits.push_back(col0.at(j)); } } moveUpwards = !moveUpwards; } } // Combine bits to codewords size_t numCodewords = version_info.total_codewords; codewords.resize(numCodewords); size_t offset = 0; for (size_t i = 0; i < numCodewords; ++i) { codewords[i] = 0; for (size_t j = 0; j < 8; ++j) { while (bits[offset] == INVALID_REGION_VALUE) { offset += 1; CV_Assert(offset < bits.size()); } codewords[i] |= (bits[offset] & 1) << (7 - j); offset += 1; } } } void QRCodeDecoderImpl::decodeSymbols(String& result) { CV_Assert(!bitstream.empty()); // Decode depends on the mode result = ""; while (!bitstream.empty()) { // Determine mode auto currMode = static_cast(bitstream.next(4)); if (this->mode == 0) { mode = currMode; } if (currMode == 0 || bitstream.empty()) return; if (currMode == QRCodeEncoder::EncodeMode::MODE_NUMERIC) decodeNumeric(result); else if (currMode == QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC) decodeAlpha(result); else if (currMode == QRCodeEncoder::EncodeMode::MODE_BYTE) decodeByte(result); else if (currMode == QRCodeEncoder::EncodeMode::MODE_ECI) decodeECI(result); else if (currMode == QRCodeEncoder::EncodeMode::MODE_KANJI) decodeKanji(result); else if (currMode == QRCodeEncoder::EncodeMode::MODE_STRUCTURED_APPEND) { sequence_num = static_cast(bitstream.next(4)); total_num = static_cast(1 + bitstream.next(4)); parity = static_cast(bitstream.next(8)); } else CV_Error(Error::StsNotImplemented, format("mode %d", currMode)); } } void QRCodeDecoderImpl::decodeNumeric(String& result) { int numDigits = bitstream.next(version <= 9 ? 10 : (version <= 26 ? 12 : 14)); for (int i = 0; i < numDigits / 3; ++i) { int triple = bitstream.next(10); result += static_cast('0' + triple / 100); result += static_cast('0' + (triple / 10) % 10); result += static_cast('0' + triple % 10); } int remainingDigits = numDigits % 3; if (remainingDigits) { int triple = bitstream.next(remainingDigits == 1 ? 4 : 7); if (remainingDigits == 2) result += '0' + (triple / 10) % 10; result += '0' + triple % 10; } } void QRCodeDecoderImpl::decodeAlpha(String& result) { static const char map[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' ', '$', '%', '*', '+', '-', '.', '/', ':'}; int num = bitstream.next(version <= 9 ? 9 : (version <= 26 ? 11 : 13)); for (int i = 0; i < num / 2; ++i) { int tuple = bitstream.next(11); result += map[tuple / 45]; result += map[tuple % 45]; } if (num % 2) { int value = bitstream.next(6); result += map[value]; } } void QRCodeDecoderImpl::decodeByte(String& result) { int num = bitstream.next(version <= 9 ? 8 : 16); for (int i = 0; i < num; ++i) { result += static_cast(bitstream.next(8)); } } void QRCodeDecoderImpl::decodeECI(String& result) { int eciAssignValue = bitstream.next(8); for (int i = 0; i < 8; ++i) { if (eciAssignValue & 1 << (7 - i)) eciAssignValue |= bitstream.next(8) << (i + 1) * 8; else break; } if (this->eci == 0) { this->eci = static_cast(eciAssignValue); } decodeSymbols(result); } void QRCodeDecoderImpl::decodeKanji(String& result) { int num = bitstream.next(version <= 9 ? 8 : (version <= 26 ? 10 : 12)); for (int i = 0; i < num; ++i) { int data = bitstream.next(13); int high_byte = data / 0xC0; int low_byte = data - high_byte * 0xC0; int symbol = (high_byte << 8) + low_byte; if (0 <= symbol && symbol <= 0x9FFC - 0x8140) { symbol += 0x8140; } else if (0xE040 - 0xC140 <= symbol && symbol <= 0xEBBF - 0xC140) { symbol += 0xC140; } result += (symbol >> 8) & 0xff; result += symbol & 0xff; } } }