Mastering OpenCV with Practical Computer Vision Projects / Опановуюємо OpenCV через практичні проекти комп'ютерного зору: Розділ 2. Доповнена реальність на iOS та Android з використанням маркерів

Зверніть увагу на код обробки помилок. Для настільки важливих процесів, як налаштування апаратного забезпечення, повернення продуманих значень є хорошою практикою. Без цього виконання коду може неочікувано перерватися, не оповістивши користувача про причини.

Atronax 17.02.21 в 08:23

Ми створили сесію захоплення та додали джерело відео. Настав час приєднати об'єкт, що отримуватиме власне дані зображень. Для обробки нестиснутих кадрів відеопотоку використовується клас AVCaptureVideoDataOutput. Камера здатна забезпечувати зображеннями у форматі BGRA, CMYK чи простій моделі у відтінках сірого. Для наших цілей найкраще підходить BGRA, оскільки цей варіант дозволяє легко показувати та оброблювати кадри. Наступний код належить функції addRawViewOutput:

Atronax 17.02.21 в 08:36

- (void) addRawViewOutput
{
/*Налаштовуємо вивід*/
AVCaptureVideoDataOutput *captureOutput = [[AVCaptureVideoDataOutput
alloc] init];
/*Поки кадр все ще обробляється в методах делегатів -
captureOutput:didOutputSampleBuffer:fromConnection:,
жодні інші зображення не додаються в чергу.
Якщо така поведінка не потрібна, встановіть значення на NO */
captureOutput.alwaysDiscardsLateVideoFrames = YES;
/*Створюємо послідовну чергу для обробки кадрів*/
dispatch_queue_t queue;
queue =
dispatch_queue_create("com.Example_MarkerBasedAR.cameraQueue",
NULL);
[captureOutput setSampleBufferDelegate:self queue:queue];
dispatch_release(queue);

Atronax 17.02.21 в 08:42

// Встановлюємо зберігання кадрів у форматі BGRA (це має підвищити
швидкість)
NSString* key = (NSString*)kCVPixelBufferPixelFormatTypeKey;
NSNumber* value = [NSNumber
numberWithUnsignedInt:kCVPixelFormatType_32BGRA];
NSDictionary* videoSettings = [NSDictionary
dictionaryWithObject:value
forKey:key];
[captureOutput setVideoSettings:videoSettings];
// Реєструємо вивід
[self.captureSession addOutput:captureOutput];
}

Atronax 17.02.21 в 08:45

Сесія захоплення нарешті налаштована. Після запуску вона отримуватиме кадри камери та відправлятиме їх у код користувача. Коли маємо нове доступне зображення, об'єкт AVCaptureSession активує функцію зворотного виклику captureOutput: didOutputSampleBuffer:fromConnection. Тут здійснюємо незначні операції над виглядом даних, щоб отримати більш зручний формат, та передаємо їх далі.

Atronax 17.02.21 в 08:52

- (void)captureOutput:(AVCaptureOutput *)captureOutput
didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
fromConnection:(AVCaptureConnection *)connection
{
// Отримуємо буфер, що зберігає кадри відео
CVImageBufferRef imageBuffer =
CMSampleBufferGetImageBuffer(sampleBuffer);
// Блокуємо буфер зображень
CVPixelBufferLockBaseAddress(imageBuffer,0);
// Збираємо інформацію про кадр
uint8_t *baseAddress = (uint8_t
*)CVPixelBufferGetBaseAddress(imageBuffer);
size_t width = CVPixelBufferGetWidth(imageBuffer);
size_t height = CVPixelBufferGetHeight(imageBuffer);
size_t stride = CVPixelBufferGetBytesPerRow(imageBuffer);
BGRAVideoFrame frame = {width, height, stride, baseAddress};
[delegate frameReady:frame];
/*Звільняємо буфер кадрів*/
CVPixelBufferUnlockBaseAddress(imageBuffer,0);
}

Atronax 17.02.21 в 08:55

Ми отримали посилання на буфер зображень, що зберігає дані кадру. Потім здійснили блокування, аби нові зображення не модифікували його. Відтепер маємо виключний доступ до об'єкта. Використовуючи програмний інтерфейс CoreVideo, отримуємо розміри кадру, протяжність (кількість пікселів у рядку) та вказівник на початок даних.

Atronax 17.02.21 в 09:00

Примітка
Зверніть увагу на пару функцій CVPixelBufferLockBaseAddress/CVPixelBufferUnlockBaseAddress в коді зворотного виклику. Поки буфер пікселів заблоковано, гарантується цілісність та коректність його даних. Зчитування можливе лише після виклику функції блокування. По завершенню роботи не забудьте звільнити буфер, щоб оперативна система змогла заповнити його новими даними.

Atronax 17.02.21 в 09:11

Розпізнавання маркера

Atronax 17.02.21 в 09:12

У більшості випадків маркер виглядає як прямокутне зображення з чорними та білими зонами всередині. Зважаючи на відомі обмеження, процедура розпізнавання є досить простою. Перш за все, необхідно знайти закриті контури вхідного кадру, розгорнути внутрішнє зображення у прямокутник та порівняти його з моделлю маркера.

Atronax 17.02.21 в 09:16

Для цього прикладу використаємо маркер з розмірами 5х5. Він виглядає так:
У книзі описано проєкт з процедурою розпізнавання маркера, що інкапсульована в класі MarkerDetector:

Atronax 17.02.21 в 09:24

/**
* Високорівневий клас, що інкапсулює алгоритм розпізнавання маркера
*/
class MarkerDetector
{
public:
/**
* Налаштовуємо новий екземпляр розпізнавача
* @calibration[in] - Калібрування камери необхідне для оцінки
пози.
*/
MarkerDetector(CameraCalibration calibration);
void processFrame(const BGRAVideoFrame& frame);
const std::vector<Transformation>& getTransformations() const;

Atronax 17.02.21 в 09:31

protected:
bool findMarkers(const BGRAVideoFrame& frame, std::vector<Marker>&
detectedMarkers);
void prepareImage(const cv::Mat& bgraMat,
cv::Mat& grayscale);
void performThreshold(const cv::Mat& grayscale,
cv::Mat& thresholdImg);
void findContours(const cv::Mat& thresholdImg,
std::vector<std::vector<cv::Point> >& contours,
int minContourPointsAllowed);
void findMarkerCandidates(const std::vector<std::vector<cv::Point>
>&
contours, std::vector<Marker>& detectedMarkers);
void detectMarkers(const cv::Mat& grayscale,
std::vector<Marker>& detectedMarkers);
void estimatePosition(std::vector<Marker>& detectedMarkers);
private:
};

Atronax 17.02.21 в 09:32

Щоб ви краще зрозуміли процедуру розпізнавання маркера, наведемо покроковий алгоритм обробки одного кадра відео. Як приклад буде використано вхідне зображення, зняте камерою iPad:

Atronax 17.02.21 в 09:36

Ідентифікація маркера

Atronax 17.02.21 в 09:37

Ось робочий потік процедури розпізнавання маркера:
1. Конвертуємо вхідне зображення у відтінки сірого.
2. Здійснюємо операцію бінарного порогу.
3. Знаходимо контури.
4. Обираємо можливі маркери.
5. Розпізнаємо їх та декодуємо.
6. Оцінюємо тривимірну позу маркера.

Atronax 17.02.21 в 09:39

Конвертація у відтінки сірого

Atronax 17.02.21 в 09:39

Перетворення у відтінки сірого важливе, адже в більшості випадків маркери складаються з чорних та білих блоків, а ними зручніше оперувати на конвертованих кадрах. На щастя, зміна простору кольорів в OpenCV доволі проста.

Atronax 17.02.21 в 09:44

Погляньте на наступний фрагмент коду C++:
void MarkerDetector::prepareImage(const cv::Mat& bgraMat, cv::Mat&
grayscale)
{
// Конвертуємо у відтінки сірого
cv::cvtColor(bgraMat, grayscale, CV_BGRA2GRAY);
}

Atronax 17.02.21 в 09:46

Ця функція перетворить вхідне зображення BGRA у відтінки сірого (за необхідності буде виділено буфери кадрів) та використає результат як другий аргумент. Усі подальші кроки здійснимо на конвертованих кадрах.

Atronax 17.02.21 в 09:51

Бінаризація зображення

Atronax 17.02.21 в 09:52

Операція бінаризації змінить колір кожного пікселя зображення на чорний (з нульовою інтенсивністю) чи білий (з повною). Цей крок необхідний для пошуку контурів. Існує декілька порогових методів; кожен має сильні та слабкі сторони. Найлегший та найшвидший метод - це абсолютний поріг, у якому результат залежить від інтенсивності поточного пікселя та деякого значення порогу. Якщо інтенсивність пікселя більша за значення порогу, результат буде білим (255); інакше чорним (0).

Atronax 17.02.21 в 10:01

Цей спосіб має величезний недолік - він залежить від умов освітлення та незначних змін інтенсивності. До кращих методів відносять адаптивний поріг. Головна його відмінність - це використання усіх пікселів в певному радіусі навколо поточного. Використання середньої інтенсивності дає прийнятні результати та дозволяє знаходити більш точні кути.

Atronax 17.02.21 в 10:18

Наступний фрагмент коду належить функції MarkerDetector:
void MarkerDetector::performThreshold(const cv::Mat& grayscale,
cv::Mat& thresholdImg)
{
cv::adaptiveThreshold(grayscale, // Вхідні дані
thresholdImg,// Бінарне зображення
255, //
cv::ADAPTIVE_THRESH_GAUSSIAN_C, //
cv::THRESH_BINARY_INV, //
7, //
7 //
);
}

Atronax 17.02.21 в 10:20

Після застосування адаптивного порогу до вхідного зображення, результат стає схожим на наступне:
Кожен маркер у більшості випадків має квадратну форму з чорними та білими зонами всередині. Тому найкращий спосіб визначити маркер полягає в пошуку закритих контурів та їх апроксимації до полігонів з 4 вершинами.

Atronax 17.02.21 в 10:22

Розпізнавання контурів

Atronax 17.02.21 в 10:22

Функція cv::findCountours розпізнає контури на вхідному бінарному зображенні:
void MarkerDetector::findContours(const cv::Mat& thresholdImg,
std::vector<std::vector<cv::Point>
>& contours,
int minContourPointsAllowed)
{
std::vector< std::vector<cv::Point> > allContours;
cv::findContours(thresholdImg, allContours, CV_RETR_LIST,
CV_CHAIN_APPROX_NONE);
contours.clear();
for (size_t i=0; i<allContours.size(); i++)
{
int contourSize = allContours[i].size();
if (contourSize > minContourPointsAllowed)
{
contours.push_back(allContours[i]);
}
}
}

Atronax 17.02.21 в 10:24

Ця функція поверне список полігонів, кожен з яких представляє єдиний контур. Вона пропускає ті з них, кількість точок яких менша за значення змінної minContourPointsAllowed. Це так, бо ми не зацікавлені в малих контурах. (Скоріше за все, вони не включатимуть маркери або контур не вдасться розпізнати через малі розміри.) Наступний малюнок показує етап візуалізації знайдених контурів:

Atronax 17.02.21 в 10:30

Пошук кандидатів

Atronax 17.02.21 в 10:30

Після знаходження контурів виконується етап апроксимації полігону. Це робиться для зниження кількості точок, що описують форму контуру. Це також непоганий контроль якості, що дозволяє відфільтрувати зони без маркерів, адже останні завжди можна представити у вигляді полігонів з чотирма вершинами. Якщо апроксимований полігон має більше або менше ніж чотири вершини, вочевидь, нам він непотрібний. Наступний код реалізує цю ідею:

Atronax 17.02.21 в 10:35

void MarkerDetector::findCandidates
(
const ContoursVector& contours,
const ContoursVector& contours,
std::vector<Marker>& detectedMarkers
)
{
std::vector<cv::Point> approxCurve;
std::vector<Marker> possibleMarkers;
// Аналізуємо кожен контур, чи
// схожий він на паралелепіпед,
// яким може виявитися маркер
for (size_t i=0; i<contours.size(); i++)
{
// Апроксимуємо до полігону
double eps = contours[i].size() * 0.05;
cv::approxPolyDP(contours[i], approxCurve, eps, true);

Atronax 17.02.21 в 14:58

// Ми зацікавлені лише в полігонах, що складаються з 4 точок
if (approxCurve.size() != 4)
continue;
// Крім цього, вони мають бути замкненими
if (!cv::isContourConvex(approxCurve))
continue;
// Впевнюємося, що відстань між послідовними точками достатньо велика
float minDist = std::numeric_limits<float>::max();
for (int i = 0; i < 4; i++)
{
cv::Point side = approxCurve[i] - approxCurve[(i+1)%4];
float squaredSideLength = side.dot(side);
minDist = std::min(minDist, squaredSideLength);
}

Atronax 17.02.21 в 17:21

// Перевіряємо, що відстань не надто мала
if (minDist < m_minContourLengthAllowed)
continue;
// Всі тести пройдено. Збережемо кандидата на маркер:
Marker m;
for (int i = 0; i<4; i++)
m.points.push_back(
cv::Point2f(approxCurve[i].x, approxCurve[i].y) );
// Сортуємо точки в порядку проти годинникової стрілки
// Проводимо лінію між першою та другою точками.
// Якщо третя знаходиться з правого боку, точки
// розміщені проти годинникової стрілки
cv::Point v1 = m.points[1] - m.points[0];
cv::Point v2 = m.points[2] - m.points[0];
double o = (v1.x * v2.y) - (v1.y * v2.x);
if (o < 0.0) // якщо третя точка з лівого боку,
// тоді здійснюємо сортування у порядку
// проти годинникової стрілки
std::swap(m.points[1], m.points[3]);

Atronax 17.02.21 в 17:26

std::swap(m.points[1], m.points[3]);
possibleMarkers.push_back(m);
}
// Видаляємо елементи, чиї кути знаходяться надто близько одна до одної.
// Спершу знайдемо кандидатів на видалення:
std::vector< std::pair<int, int> > tooNearCandidates;
for (size_t i=0;i<possibleMarkers.size();i++)
{
const Marker& m1 = possibleMarkers[i];
// вирахуємо середню відстань від кожного кута до
// найближчого кута іншого кандидата в маркери
for (size_t j=i+1;j<possibleMarkers.size();j++)
{
const Marker& m2 = possibleMarkers[j];

Atronax 17.02.21 в 17:30

float distSquared = 0;
for (int c = 0; c < 4; c++)
{
cv::Point v = m1.points[c] - m2.points[c];
distSquared += v.dot(v);
}
distSquared /= 4;
if (distSquared < 100)
{
tooNearCandidates.push_back(std::pair<int,int>(i,j));
}
}
}

Atronax 17.02.21 в 17:31

// Помітимо на видалення елемент пари з меншим периметром
std::vector<bool> removalMask (possibleMarkers.size(), false);
for (size_t i=0; i<tooNearCandidates.size(); i++)
{
float p1 =
perimeter(possibleMarkers[tooNearCandidates[i].first
].points);
float p2 =
perimeter(possibleMarkers[tooNearCandidates[i].second].points);
size_t removalIndex;
if (p1 > p2)
removalIndex = tooNearCandidates[i].second;
else
removalIndex = tooNearCandidates[i].first;
removalMask[removalIndex] = true;
}

Atronax 17.02.21 в 17:32

// Повертаємо кандидатів
detectedMarkers.clear();
for (size_t i=0;i<possibleMarkers.size();i++)
for (size_t i=0;i<possibleMarkers.size();i++)
{
if (!removalMask[i])
detectedMarkers.push_back(possibleMarkers[i]);
}
}

Atronax 17.02.21 в 17:32

Відтепер маємо список паралелепіпедів, які з певною мірою вірогідності представлятимуть маркери. Щоб підтвердити приналежність, здійснюємо три кроки:
1. По-перше, видаляємо проєкцію перспективи, щоб отримати фронтальний вид прямокутної зони.
2. Потім виконуємо процедуру порогу на зображенні з використанням алгоритму Отсу, що припускає використання бімодального розподілу та знаходить порогове значення, яке максимізує дисперсію для зовнішнього класу та зберігає для внутрішнього.
3. Нарешті здійснюємо ідентифікацію кода маркера. Якщо це саме він, внутрішній код має існувати. Маркер розділено на сітку блоків розмірами 7х7, з яких внутрішні 5х5 зберігають інформацію про ID. Решта відповідає зовнішній чорній границі. На цьому етапі ми спочатку перевіряємо, чи присутня вона взагалі. Потім зчитуємо внутрішні 5х5 блоків та перевіряємо, чи формують вони дійсний код. (Може знадобитися перевернути зображення, щоб отримати дійсний код.)

Atronax 17.02.21 в 17:50

Щоб отримати прямокутний маркер, потрібно розгорнути вхідне зображення з використанням перспективних перетворень. Необхідну матрицю можна вирахувати за допомогою функції cv::getPerspectiveTransform. Вона знаходить перетворення для 4 пар відповідних точок. Перший аргумент - це координати маркера у просторі зображення, а другий відповідає координатам квадратного фрагмента маркера. Знайдені перетворення нададуть маркеру квадратної форми та дозволять його проаналізувати:
cv::Mat canonicalMarker;
Marker& marker = detectedMarkers[i];
// Знаходимо перетворення перспективи, що нададуть поточному маркеру
// прямокутної форми
cv::Mat M = cv::getPerspectiveTransform(marker.points,
m_markerCorners2d);
// Трансформуємо зображення, щоб отримати канонічне зображення маркера
cv::warpPerspective(grayscale, canonicalMarker, M, markerSize);

Atronax 17.02.21 в 18:01

Розгортання зображення надає йому прямокутної форми за допомогою перетворень перспективи:
Приступимо до перевірки зображення на приналежність до дійсних маркерів. Потім спробуємо здобути бітову маску з кодом маркера. Оскільки ми очікуємо, що маркер включає лише чорні та білі кольори, застосуємо поріг Отсу, щоб видалити сірі пікселі та залишити решту:
// зображення порогу
cv::threshold(markerImage, markerImage, 125, 255, cv::THRESH_BINARY |
cv::THRESH_OTSU);

Atronax 17.02.21 в 18:06

Розпізнавання кода маркера

Atronax 17.02.21 в 18:07

Кожен маркер має внутрішній код, описаний 5 словами по 5 бітів в кожному. Застосований шифр є дещо зміненим кодом Хеммінга. В загальному кожне слово має 2 біти корисної інформації з 5 використаних. Решта 3 потрібні для розпізнавання помилок. Як результат, можна отримати до 1024 різних ідентифікаторів.

Atronax 17.02.21 в 18:15

Головна відмінність від базового коду - це те, що перший біт (паритет 3 та 5) інвертовано. Тому ідентифікатор 0 (що описується 5 нулями) стає 10000 в нашому коді. Завдяки цьому можна запобігти явищу, коли повністю чорний маркер виявляється дійсним ідентифікатором. Це необхідно, щоб зменшити кількість хибних появ серед об'єктів середовища.

Atronax 17.02.21 в 18:30

Підрахунок кількості чорних та білих пікселів для кожного блока дає маску розмірності 5х5 з кодом маркера. Щоб знайти число ненульових пікселів на певному зображенні, застосовано функцію cv::countNonZero. Вона рахує ненульові елементи заданого одно- чи двовимірного масиву. Клас cv::Mat здатний повертати новий екземпляр, що включає частину початкового зображення. Наприклад, якщо існує cv::Mat з розмірами 400х400, наступний фрагмент коду створить підматрицю для блоку зображення з координатами (:10,10) та розмірами 50х50:
cv::Mat src(400,400,CV_8UC1);
cv::Rect r(10,10,50,50);
cv::Mat subView = src(r);

Atronax 17.02.21 в 18:43

Зчитування коду маркера

Atronax 17.02.21 в 18:43

Використовуючи цю техніку, можна знайти блоки на поверхні маркера:
cv::Mat bitMatrix = cv::Mat::zeros(5,5,CV_8UC1);
// отримуємо інформацію (для кожного внутрішнього квадрата, визначаємо, чорний він чи білий)
for (int y=0;y<5;y++)
{
for (int x=0;x<5;x++)
{
int cellX = (x+1)*cellSize;
int cellY = (y+1)*cellSize;
cv::Mat cell = grey(cv::Rect(cellX,cellY,cellSize,cellSize));
int nZ = cv::countNonZero(cell);
if (nZ> (cellSize*cellSize) /2)
bitMatrix.at<uchar>(y,x) = 1;
}
}

Atronax 17.02.21 в 18:46

Зверніть увагу на наступний малюнок. Той же маркер може мати чотири можливі представлення залежно від точки зору камери:

Atronax 17.02.21 в 18:47

Оскільки існує 4 можливі орієнтації малюнку маркера, потрібно знайти коректну позицію маркера. Пам'ятайте, для кожних 2 бітів інформації доступні 3 для перевірки. Завдяки їм можна знайти відстань Хеммінга для кожної можливої орієнтації маркера. Правильна позиція матиме нульову похибку відстані, а інші варіанти повороту - ні.

Atronax 17.02.21 в 18:53

Далі розміщено код, що повертає бітову матрицю 4 рази та знаходить вірну орієнтацію маркера:
// перевіряємо всі можливі повороти
cv::Mat rotations[4];
int distances[4];
rotations[0] = bitMatrix;
distances[0] = hammDistMarker(rotations[0]);
std::pair<int,int> minDist(distances[0],0);
for (int i=1; i<4; i++)
{
// отримуємо відстань Хеммінга до найближчого можливого слова
rotations[i] = rotate(rotations[i-1]);
distances[i] = hammDistMarker(rotations[i]);
if (distances[i] < minDist.first)
{
minDist.first = distances[i];
minDist.second = i;
}
}

Atronax 17.02.21 в 18:56

Цей код знаходить орієнтацію бітової матриці таким чином, щоб мати мінімальну похибку для вимірів відстані Хеммінга. Вона має бути нульовою для коректного ідентифікатора маркера; якщо це не так, ми маємо невірний шаблон маркера (зіпсоване зображення чи розпізнавання хибних появ).

Atronax 17.02.21 в 19:01