std::map<std::string, char> mapping;

for (int i = 0; i < C39_NCHARACTERS; i++) {

mapping[C39_Strings[i]] = C39_Characters[i];

}

return mapping;

//stripeCode codeNow;

//Walk the code and extract words

imwrite("/Users/tzaman/Desktop/bc/c39_image.png", image);

std::vector<double> intervals_black;

std::vector<double> intervals_white;

//We will now perform smart measurement of the white and black stripes.

char prev_char = image.at<char>(0);

int current_length = 0;

for (int i = 1; i < image.rows * image.cols; i++) {

char current_char = image.at<char>(i);

current_length++;

if (current_char != prev_char) {

//Switch

if (prev_char == 0) {

intervals_black.push_back(current_length);

} else {

intervals_white.push_back(current_length);

}

current_length = 0; //reset

}

prev_char = current_char;

}

intervals_white.erase(intervals_white.begin()); //erase first white index (as the barcode itself starts with black, but background with white)

int width_wide_narrow_division_white = util::calcMeanOfQuarterAndThreeQuarterPercentile(intervals_white);

int width_wide_narrow_division_black = util::calcMeanOfQuarterAndThreeQuarterPercentile(intervals_black);

// Account for the fact that character spacing is thin and more thin divisors that wide

width_wide_narrow_division_white *= 1.3;

// Account for the fact that at most 2/5 are black wide.

width_wide_narrow_division_black *= 1.1;

double width_max = std::max(width_wide_narrow_division_white, width_wide_narrow_division_black) * 2.5;

/*

std::vector<char> words;

char prevbc = 255; // White is start and base color

int lengthnow = 0;

for (int i = 0; i < image.rows * image.cols; i++) {

char curbc = image.at<char>(i); //Current value (1/0)

if (curbc != prevbc) { // 1/0 (255/0) switch

//if ((lengthnow > width_min) && (lengthnow < width_max)) {

if ((lengthnow < width_max)) {

// The width division threshold is dependent on the color.

// This takes into account the amount of ink used (f.e. less ink -> narrow black division)

int division_width_threshold = prevbc == 0 ? width_wide_narrow_division_black : width_wide_narrow_division_white;

words.push_back(lengthnow > division_width_threshold ? 'w' : 'n');

} else {

//cout << "word ignored. l=" << lengthnow << endl;

words.push_back('X');

}

//cout << lengthnow << " ";

lengthnow = 0; //Reset length

}

prevbc = curbc;

lengthnow++;

}

//cout << endl;

std::string bc_string(words.begin(), words.end());

//We now have a word array in which 'n'=narrow, 'w'=wide, 'X'=very wide/invalid

/*

//Generate the decoding map

//std::map<std::string, char> decoding = generateDecodingMap();

//Look for start and stop asterisk

int bc_start_idx = -1;

int bc_stop_idx = -1;

int max_asterisk_start_bars = this->opts_->getValue<int>("C39_DEC_MAX_ASTERISK_START_BARS", 9);

// Test for verse and inverse

for (int rev = 0; rev <= 1; rev++) {

for (int j = 0; j < max_asterisk_start_bars; j++) {

std::map<std::string, char>::const_iterator it;

std::string curr = bc_string.substr(j, C39_BARS_PER_CHAR);

it = DECODINGMAP_C39.find(curr);

if(it == DECODINGMAP_C39.end()){

//cout << "NOPE." << endl;

} else if (it->second == C39_SENTINEL) {

bc_start_idx = j + C39_BARS_PER_CHAR + 1;

//cout << "FOUND:" << it->second << endl;

}

}

for (int j = bc_string.length() - C39_BARS_PER_CHAR; j > bc_string.length() - max_asterisk_start_bars - C39_BARS_PER_CHAR; j--) {

std::map<std::string, char>::const_iterator it;

std::string curr = bc_string.substr(j, C39_BARS_PER_CHAR);

it = DECODINGMAP_C39.find(curr);

if (it == DECODINGMAP_C39.end()) {

// ..

} else if (it->second == C39_SENTINEL) {

bc_stop_idx = j;

// std::cout << "FOUND:" << it->second << std::endl;

}

}

if (bc_start_idx != -1 && bc_stop_idx != -1) {

break; // Two asterisks found.

} else { // Did not find two asterisks.

// Try the next iteration in reverse if applicable

std::reverse(std::begin(bc_string), std::end(bc_string));

}

}

if (bc_start_idx == -1) {

// std::cout << "Code 39 start asterisk not found." << std::endl;

return RET_NONE_FOUND;

} else if (bc_stop_idx == -1) {

// std::cout << "Code 39 stop asterisk not found." << std::endl;

return RET_NONE_FOUND;

}

// std::cout << "bc_start_idx=" << bc_start_idx << " bc_stop_idx=" << bc_stop_idx << std::endl;

std::string strRaw = bc_string.substr(bc_start_idx, bc_stop_idx - bc_start_idx + C39_BARS_PER_CHAR);

/*

// Decode the whole data from asterisk to asterisk

std::string barcode_str;

bool decoding_all_ok = true;

for (int j = bc_start_idx; j < bc_stop_idx; j += C39_BARS_PER_CHAR + 1) {

std::string curr = bc_string.substr(j, C39_BARS_PER_CHAR);

//cout << j << " curr=" << curr << endl;

std::map<std::string, char>::const_iterator it;

it = DECODINGMAP_C39.find(curr);

if(it == DECODINGMAP_C39.end()){

// std::cout << "Code 39 unknown decoding sequence: '" << curr << "' from position " << std::to_string(j) << std::endl;

decoding_all_ok = false;

break;

} else {

barcode_str += (it->second);

}

}

if (!decoding_all_ok) {

// std::cout << "Code 39 found unknown decoding sequence somewhere, ignoring.." << std::endl;

return RET_NONE_FOUND;

}

//cout << "BARCODE: " << barcode << " raw=" << strRaw << endl;

current_code->data = barcode_str;

current_code->data_raw = strRaw;

return RET_SUCCESS;