Пишем сканер штрихкодов на c++

Не так давно у меня возникла необходимость в сканере штрихкода. Конечно можно было бы взять готовый сканнер откуда-нибудь из интернета, НО зачем? Зачем если можем написать сами? Именно с такими мыслями я сел и написал собственный сканер штрихкода. Правда сканирует пока что только из изображений, но это исправимо.

Что же такое штрихкод

Штрихово́й код  — графическая информация, наносимая на поверхность, маркировку или упаковку изделий, предоставляющая возможность считывания её техническими средствами — последовательность чёрных и белых полос, либо других геометрических фигур.

Такое определение штрихкода даётся на википедии. Штрихкоды мы можем найти на практически всех современных товарах. Они удобны в использовании. Существует несколько разновидностей штрихкодов EAN-8 EAN-13 UPC code56... Я же написал сканнер только для EAN-8 и   EAN-13.

---

Непосредственно код

Ну что ж, перейдём от слов к делу... У нас есть два штрихкода в формате png:

Изображения

EAN-8

EAN-13

Я сгенерировал их на первых в результатах поиска онлайн генераторах штрихкодов

Я прочитал эти изображения тем, что было под рукой - библиотекой OpenCV. Возможно это излишество как считаете?

cv::Mat image = cv::imread((const char*)source, cv::IMREAD_GRAYSCALE);

Изображение считывается чёрно-белым и записывается в матрицу cv::Mat. Далее необходимо вырезать из матрицы по центральной высоте полоску длиной в ширину изображения и высотой в 1 пиксель ( widthx1):

cv::Mat formatted(image, // image - наша первоначальная матрица изображения
  cv::Rect(0, (unsigned int)(image.rows / 2), image.cols, 1) // // прямоугольник необходимых размеров и с необходимой позицией
); 

Теперь переведём матрицу в удобный формат массива байт-пикселей (1байт=1пиксель) std::vector:

std::vector<unsigned char> fByteArray; // Наш итоговый массив значений пикселей
cv::Point point(0, 0); // точка-позиция в полосочке
for (int col = 0; col < formatted.cols; col++) {
  point.x = col;
  unsigned char el = formatted.at<unsigned char>(point); // получаем значение пикселя в позиции point
  el = 255 - el; // инвертируем
  if (el >= 255 / 2) { // проверяем пиксель на чёрный/белый - 1/0 в итоговом массиве
    fByteArray.push_back(1); // пиксель чёрный - добавим 1
  }else
    fByteArray.push_back(0); // пиксель белый - добавим 0
}

Здесь мы получаем значение пикселя по позиции point из отформатированной матрицы, инвертируем его (для удобства и понятности) и приравниваем в fByteArray всем белым пикселям значение 0, а всем чёрным значение 1.
Для того чтобы понять какая точка (пиксель) белая, а какая чёрная мы сравниваем значение этой точки со средним значением в цветовой палитре (серым) - 255/2. Если значение точки больше среднего, то точка белая (1), если меньше - чёрная (0)

Для чего мы инвертируем значение пикселя

Дело в том, что в компьютере цвета кодируются в порядке от чёрного (значение цвета = 0) к белому (значение цвета = 255). Условно можно обозначить чёрный, как 0, а белый как 1. В штрихкоде же наоборот: белые полосочки - это нули, а чёрные - это единички. И именно поэтому для того, чтобы не запутаться лучше пиксель инвертировать.

Освобождаем матрицы и на всякий случай проверяем не пустой ли у нас вектор fByteArray:

image.release();
formatted.release();

if (fByteArray.empty())
  return false;

fByteArray представляет из себя массив нулей и единиц соответственно пикселям матрицы formatted. Мы должны измерить ширину каждой полоски в штрихкоде.
Для этого мы сохраняем первый элемент массива в переменную lastStat.
В count сохраняем количество последовательных элементов с одинаковыми значениям в массиве.
В цикле проходимся по элементам массива, при этом вне зависимости от значения первого и последнего потоков подобных элементов их пропускаем (он всё равно не несут смысловой нагрузки). Далее начинаем подсчитывать количество подобных элементов записываем полученное число count в массив arrays. Изменяем lastStat на значение нового отличного элемента в массиве и приравниваем count единице.

unsigned char lastStat = fByteArray[0]; // сохраняем значение первого элемента
unsigned int count = 0; // количество одинаковых элементов
std::vector<unsigned int> arrays; // массив "потоков" одинаковых значений
for (unsigned char el : fByteArray) { // объяснено выше и ниже
  if (lastStat != (bool)el) {
    if (count != 0)
      arrays.push_back(count);
    lastStat = (bool)el;
	count = 1;
	continue;
  }
  if(count != 0)
    count++;
}

Для тех кто не понял или понял плохо

Представим у нас есть массив значений:
[0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0]

Перед циклом lastStat приравнивается первому элементу массива, в нашем случае:
lastStat = 0

Первые подобные элементы пропускаются и не входят в arrays, но как только мы доходим до первого отличного от прошлого элемента (позиция 4 в массиве | 1 |), программа начинает считать количество подобных элементов и так, как первый подобный уже в el, то count = 1. Программа натыкается на следующий отличный элемент и count добавляется в arrays.В нашем случае count = 3, и так далее программа работает до последнего элемента fByteArray.

В результате цикла получается массив std::vector arrays, со следующими значениями:
[3, 4, 6]

Надеюсь вы поняли, объяснил как смог:)

Освобождаем память и проверяем итоговый массив arrays:

fByteArray.clear();
if (arrays.empty()) {
  return false;
}

Теперь необходимо найти чему равна ширина одного элемента в штрихкоде. Как же это найти?
Дело в том, что ширина одного элемента штрихкода (нуля или единицы) зашифровано в самом же штрихкоде - первые три полоски, срединные три полоски (они служат ещё для одной цели, но об этом позже) и последние три полоски. Все они идут чередуясь чёрная, белая, чёрная и ширина одной из полосок = ширина одного элемента в штрихкоде.

Я реализовал поиск таких трёх полосок максимально просто - я нахожу три первых одинаковых по ширине элемента arrays и записываю из значение в переменную, затем выхожу из цикла:

unsigned int CountPixelsInOne = 0;
for (unsigned int i = 0; i < arrays.size(); i++) {
  if (i + 2 >= arrays.size())
    return false; // не нашли нужные три полоски, а массив завершился - штрихкод повреждён или прочитан неправильно
  if (arrays[i] == arrays[i + 1]) {
    if (arrays[i + 1] == arrays[i + 2]) {
      CountPixelsInOne = arrays[i];
      break; // последовательность найдена, значение сохранено - ломаем цикл и работаем дальше
    }
  }
}

Найдём количество нулей или единиц в каждой из полосок штрихкода. Для этого разделим ширину полоски в пикселях на количество пикселей в "базовом" элементе штрихкода и прибавляем остаток от деления (обычно он в районе одного пикселя, поэтому о точности можно не беспокоиться). Получившееся значение записываем в fByteArray, очищаем массив arrays:

for (unsigned int i : arrays) {
  fByteArray.push_back((i / CountPixelsInOne) + (i % CountPixelsInOne));
}
arrays.clear();

А теперь осталось перевести штрихкод в последовательность "бит" штрихкода:

std::vector<unsigned char> EncValues; // Enc = encrypted
for (unsigned int i = 1; i <= fByteArray.size(); i++) {
  unsigned int count = fByteArray[i - 1];
  for (unsigned int j = 0; j < count; j++)
  {
    if (i % 2 == 0)
      EncValues.push_back('0');
    else
      EncValues.push_back('1');
  }
}
fByteArray.clear();

Здесь, в цикле мы проходимся по массиву длин полосок штрихкода fByteArray, при чём начальное значениеi равно единице только лишь для удобства. Получаем значение элемента i-1 из fByteArray, далее входим в новый цикл и добавляем столько нулей или единиц в EncValues, скольки равен элемент массива fByteArray. Добавляем мы единичку или нуль зависит от чётности полоски штрихкода. Поздравляю мы близки к победе - мы получили последовательность зашифрованных бит в штрихкоде!
P.S. В программе подразумевается то, что все нечётные полоски - чёрные(1), а чётные - белые(0). В прочем так и выходит при работе всего вышеприведённого кода.

std::vector<unsigned int> result;
if (Try_EAN8(EncValues, result)) {
  EncValues.clear();
}
else if (Try_EAN13(EncValues, result)) {
  EncValues.clear();
}
else {
  return false;
}

Здесь всё просто: result - переменная со значением результата сканирования штрихкода. Для начала мы пробуем сканировать штрихкод, как EAN-8, если не получилось то, как EAN-13, если снова не получилось - значит программа не поддерживает такой вид штрихкода или штрихкод не верен - return false;

---

Для дальнейшей работы нам потребуется чуть глубже вникнуть в устройство штрихкода. Дело в том, что каждая циферка штрихкода кодируется 7ю битами. Значение каждых 7 бит зашифровано в таблицах (т.е. какой цифре равна та или иная последовательность 7 бит - в таблице). Есть несколько разновидностей кодов L-code, R-code и G-code, а так же LG-code:

Таблицы кодов

Цифра	L-код	R-код	G-код
0	0001101	1110010	0100111
1	0011001	1100110	0110011
2	0010011	1101100	0011011
3	0111101	1000010	0100001
4	0100011	1011100	0011101
5	0110001	1001110	0111001
6	0101111	1010000	0000101
7	0111011	1000100	0010001
8	0110111	1001000	0001001
9	0001011	1110100	0010111

В EAN-13 есть ещё LG-code:

Первая цифра	Первая (левая) группа из 6 цифр
0	LLLLLL
1	LLGLGG
2	LLGGLG
3	LLGGGL
4	LGLLGG
5	LGGLLG
6	LGGGLL
7	LGLGLG
8	LGLGGL
9	LGGLGL

Взято с википедии

В коде я каждую из них записал в std::vector<const char*>:

Таблицы кодов в коде (простите)

std::vector<const char*> L_code = {
	"0001101", "0011001", "0010011",
	"0111101", "0100011", "0110001",
	"0101111", "0111011", "0110111",
			   "0001011"
};

std::vector<const char*> R_code = {
	"1110010", "1100110", "1101100",
	"1000010", "1011100", "1001110",
	"1010000", "1000100", "1001000",
			   "1110100"
};

std::vector<const char*> G_code = {
	"0100111", "0110011", "0011011",
	"0100001", "0011101", "0111001",
	"0000101", "0010001", "0001001",
			   "0010111"
};

std::vector<const char*> LG_code = {
	"LLLLLL", "LLGLGG", "LLGGLG",
	"LLGGGL", "LGLLGG", "LGGLLG",
	"LGGGLL", "LGLGLG", "LGLGGL",
			   "LGGLGL"
};

Простите за тавтологию в заглавии :)

Try_EAN8 - функция

Эта функция проверяет входной std::vector<unsigned char> нулей и единиц (бит) штрихкода, проходится по нему и выдаёт выходной std::vector<unsigned int> зашифрованных в штрихкоде циферок.

if (input.size() != 67)
  return false;

Первым делом проверим количество элементов во входном std::vector. Его размер при правильном считывании штрихкода EAN-8 всегда равен 67=3+(4*7)+1+3+1+(4*7)+3:
3 - первые три вспомогательные полоски
4*7 - 4 циферки по 7бит каждая
1+3+1 - вспомогательные полоски по центру
4*7 - следующие 4 циферки по 7бит каждая
3 - последние 3 вспомогательные полоски

std::vector<unsigned int> NumsArrsEAN8;
unsigned char* Bits7 = new unsigned char[8];
Bits7[7] = 0;
for (unsigned int i = 3; i < input.size() - 3;) {
  Bits7[0] = input[i];
  Bits7[1] = input[i+1];
  Bits7[2] = input[i+2];
  Bits7[3] = input[i+3];
  Bits7[4] = input[i+4];
  Bits7[5] = input[i+5];
  Bits7[6] = input[i+6];
  unsigned int x;
  if ((x = CheckCodeTable(Bits7, L_code)) <= 9) {
    NumsArrsEAN8.push_back(x);
	i += 7;
  }
  else if ((x = CheckCodeTable(Bits7, R_code)) <= 9) {
    NumsArrsEAN8.push_back(x);
    i += 7;
  }
  else {
    i += 5;
  }
}

Здесь сперва мы определяем выходной std::vector NumArrsEAN8, массив циферки штрихкода (1циферка = 7 бит) Bits7. 8ой элемент массива для нуль-терминатора \0.
Входим в цикл, в котором мы пропускаем первые и последние три элемента - вспомогательные полоски в начале и конце. Вписываем в Bits7 элементы массива input с i по i+6 - семь "бит" штрихкода. Сравниваем их с таблицами кодов.
Первые 4 циферки EAN-8 закодированы по таблице L-code, а следующие 4 цифры - по таблице R-code.
Удобно, что ни в одной из таблиц нет элементов одинаковых с другой таблицей, поэтому можно просто по порядку проверять на совпадение тех или иных 7бит с той или иной таблицей кодов не заморачиваясь с проверками на правую или левую части штрихкода.
То, что возвращаемое CheckCodeTable значение должно быть меньше 9 понятно из обыкновенной математики - цифр всего десять (0-9).

В случае, если проверка ни на одну из таблиц кодов не прошла полагаем, что мы наткнулись на средние три вспомогательные полоски и пропускаем 5 элементов - 1 белая линия, 3 вспомогательные полоски и ещё 1 белая линия.

CheckCodeTable

unsigned int CheckCodeTable(unsigned char Bits7[8], std::vector<const char*> codeTable) {
	if (codeTable.size() == 10)
		return 0x0fffffffu; // неправильно задана таблица кодов

	for (int i = 0; i < 10; i++) {
		if (std::strncmp((const char*)Bits7, codeTable[i], 7) == 0) {
			return i; // возвращаем зашифрованную циферку
		}
	}

	return 0xffffffffu; // в таблице кодов совпадения не обнаружено
}

Первым делом проверяется соответствует ли размер таблицы 10ти (количество цифр), если нет возвращается код ошибки размера таблицы (проверку возвращаемых значений я реализовал не полно). Далее в цикле проходимся по таблице и сравниваем значения её элементов со значением массива Bits7 и если совпадение найдено возвращает индекс элемента в массиве, если нет, то возвращает (unsigned int)(-1).

Далее необходимо найти контрольное значение и сравнить его с последней (контрольной) циферкой штрихкода:

delete Bits7; // спасаемся от утечек памяти и всего подобного им
if (NumsArrsEAN8.size() != 8) // восемь ли циферок у нас получилось?
  return false; // Штрихкод - неверен или повреждён (3й вариант "руки из попы" - исключён)

unsigned int Control = (
			10 - (
				((NumsArrsEAN8[0] + NumsArrsEAN8[2] + NumsArrsEAN8[4] + NumsArrsEAN8[6]) * 3) + 
				(NumsArrsEAN8[1] + NumsArrsEAN8[3] + NumsArrsEAN8[5])) % 10
  );
Control = Control == 10 ? 0 : Control;

Контрольная циферка в EAN-8 находится следующим образом: складываем все циферки на нечётных позициях, сумму умножаем на 3. К полученному прибавляем сумму всех циферок на чётных позициях (кроме последней - она контрольная мы её типо не знаем). Итоговое число делим на десять и остаток от деления отнимаем от десяти.

В прочем, ничего сложного в реализации нет, НО стоит учитывать один момент если контрольное число получилось равным десяти, то приравниваем его нулю (циферок то всего лишь от нуля до девяти включительно).
P.S. Думаю можно было бы это реализовать и в одну строчку кода - повторное деление по модулю контрольного числа на десять, но и так сойдёт...

if (Control != NumsArrsEAN8[7])
  return false;

for (unsigned int i : NumsArrsEAN8) {
  output.push_back(i);
}
NumsArrsEAN8.clear();
return true;

Сравниваем полученное и прочитанное контрольные числа. Копируем все элементы NumsArrsEAN8 в выходной массив output, очищаем NumsArrsEAN8 и возвращаем истину в знак успешного считывания. Мои поздравления - код работает!

Try_EAN13

В целом код для сканирования EAN-13 и EAN-8 похожи, так же как и сами штрихкоды.

if (input.size() != 95) // новый размер. Больше циферок - больше размер (математика такая же как у EAN-8, но только для 12ти цифр)
  return false;

std::vector<unsigned int> BitsArrsEAN8;
NumsArrsEAN8.push_back(0); // оставляем прозапас место для 1ой цифры
std::string LG_ = ""; // новое
unsigned char* Bits7 = new unsigned char[8];
unsigned int x;
Bits7[7] = 0;
for (unsigned int i = 3; i < input.size() - 3;) {
  Bits7[0] = input[i];
  Bits7[1] = input[i + 1];
  Bits7[2] = input[i + 2];
  Bits7[3] = input[i + 3];
  Bits7[4] = input[i + 4];
  Bits7[5] = input[i + 5];
  Bits7[6] = input[i + 6];
		
  if ((x = CheckCodeTable(Bits7, L_code)) <= 9) {
    NumsArrsEAN8.push_back(x);
    LG_ += "L"; // новое
    i += 7;
  }
  else if ((x = CheckCodeTable(Bits7, R_code)) <= 9) {
    NumsArrsEAN8.push_back(x);
    i += 7; 
  }
  else if ((x = CheckCodeTable(Bits7, G_code)) <= 9) {
    NumsArrsEAN8.push_back(x);
    LG_ += "G"; // новое
    i += 7;
  }
  else {
    i += 5;
  }
}

Всё так же сравниваем размер исходного массива с требуемым, в цикле проходимся по 7 бит на циферку (кроме первой цифры, о ней позже), пропускаем средние вспомогательные полоски (5 бит), записываем полученные значения в массив NumsArrsEAN8.
Из нового: LG_code - теперь левая половина штрихкода шифруется не только с помощью L_code, но и G_code. Если попался L_code, то записываем в массив LG_ символ L, попался G_code - символ G.

delete Bits7;
if ((x = CheckCodeTable((unsigned char*)LG_.c_str(), LG_code, 6)) > 9)
  return false;

NumsArrsEAN8[0] = x;

Мы уже нашли последовательность байт LG_ при нахождении циферок левой половины штрихкода. Теперь надо найти циферку-код страны - это самая первая циферка штрихкода, она то и зашифрована LG_ байтами. По уже известному алгоритму находим эту циферку и запишем по нулевой позиции в NumsArrsEAN8.

if (NumsArrsEAN8.size() != 13)
  return false;
  
unsigned int Control = 
  (10 - (
    ((NumsArrsEAN8[1] + NumsArrsEAN8[3] + NumsArrsEAN8[5] + NumsArrsEAN8[7] + NumsArrsEAN8[9] + NumsArrsEAN8[11]) * 3) 
    +(NumsArrsEAN8[0] + NumsArrsEAN8[2] + NumsArrsEAN8[4] + NumsArrsEAN8[6] + NumsArrsEAN8[8] + NumsArrsEAN8[10])) 
   % 10 );
	Control = Control == 10 ? 0 : Control;

Сравниваем размер массива циферок с требуемым (13). Находим контрольное число по уже знакомому нам алгоритму.

if (Control != NumsArrsEAN8[12])
  return false;

for (unsigned int i : NumsArrsEAN8) {
  output.push_back(i);
}
NumsArrsEAN8.clear();
return true;

Сравниваем контрольную циферку с последней в штрихкоде (тоже контрольной). Копируем значения всех элементов NumsArrsEAN8 в выходной массив и возвращаем истину.

---

Ссылка на файл с полным кодом (немного видоизменённый): github.
Благодарю за то, что уделили время прочтению этой достаточно объёмной статьи❤️! Как всегда буду рад конструктивной критики и полезным замечаниям. Всем до новых встреч!