ESP32-CAM выделение границ на изображении перекресным оператором Робертса

Одной из задач машинного зрения является отделение одних объектов, на изображении, от других. А одним из путей решения данной задачи может быть например выделение границ путем определения переходов цветов на изображении. Одним из ранних алгоритмов для этого является выделение границ перекресным оператором робертса. Существуют более современные алгоритмы (оператор Собеля, оператор Айверсона и т.д.) но оператор Робертса является простым и быстрым по этому используется поныне и подходит для недорогой платы за 5 долларов. Реализовывать алгоритмы машинного зрения можно проще, используя например javascript библиотеку opencv. Но такой подход работает только если есть связь модуля с компьютером т.к. opencv слишком тяжелая и ресурсозатратная библиотека для модуля ESP32-CAM если нужна автономность (которая может быть важна для автоматизации) то алгоритмы машинного зрения нужно реализовывать на стороне сервера. В данном блоге уже есть статья о том как получить массив пикселей с фотографии модуля ESP32 CAM. (см. датчик цвета на ESP32-CAM -> https://electe.blogspot.com/2022/11/esp32-cam.html). Далее, после того как массив пикселей получен, можно подвергать его воздействию всевозможных алгоритмов с целью их исследования. Массив пикселей содержит 3 байта на каждый пиксель. Один байт для яркости синей составляющей, один для зеленой и один для красной. Именно в таком порядке, как было выяснено ранее, компоненты располагаются в получаемом массиве.

Однако для понимания работы алгоритма порядок не важен. Предположим что каждый пиксель имеет всего одну компоненту яркости т.е. изображение не цветное. В таком случае для определения границы какого либо объекта в какой либо точке на изображении из 4х пикселей можно найти корень из суммы квадратов разностей двух пикселей находящихся на разных диагоналях:

или сумму модулей разностей яркостей пикселей на диагоналях. Будут ли использоваться модули или корень - не важно с точки зрения результата абстрактного алгоритма но для работы на реальном процессоре, вариант с модулями более предпочтителен т.к. его быстродействие будет больше. Суть метода заключается в том что с какой бы стороны на какую не менялся цвет, в этом перекрестии, это изменение будет выражено положительным значением результата вычисления данной формулы. Для того чтобы увидеть границы объектов, на изображении, нужно пройтись данной формулой по всем этим точкам из 4 пискелей со смещением на один пиксель на каждой итерации не затрагивая крайние справа и снизу пиксели всего изображения т.к. они сильно не повлияют на результат какой либо реальной фотографии с не очень низким разрешением. Прелесть этого метода (помимо быстродействия) также заключается в том что результат вычисления можно записывать в ту же самую матрицу из которой берутся яркости пикселей изображения, что не требует дополнительного выделения оперативной памяти чем её экономит. Прежде чем применить данный алгоритм к цветному изображению, можно сначала пройтись по всей матрице и усреднить значение трех компонент яркости каждого пикселя или же пройтись оператором Робертса по каждым компонентам в отдельности. Как будет показано в видео, внизу страницы, на практике визуально результат получается практически одинаковым.

Код скетча можно скопировать из текстового поля:

#include "esp_camera.h" #include <WiFi.h> #include "esp_http_server.h" #include "esp_timer.h" #include "img_converters.h" #include "Arduino.h" #include "fb_gfx.h" #include "fd_forward.h" #include "fr_forward.h" #define ENROLL_CONFIRM_TIMES 5 #define FACE_ID_SAVE_NUMBER 7 #define FACE_COLOR_WHITE 0x00FFFFFF #define FACE_COLOR_BLACK 0x00000000 #define FACE_COLOR_RED 0x000000FF #define FACE_COLOR_GREEN 0x0000FF00 #define FACE_COLOR_BLUE 0x00FF0000 #define FACE_COLOR_YELLOW (FACE_COLOR_RED | FACE_COLOR_GREEN) #define FACE_COLOR_CYAN (FACE_COLOR_BLUE | FACE_COLOR_GREEN) #define FACE_COLOR_PURPLE (FACE_COLOR_BLUE | FACE_COLOR_RED) // // WARNING!!! PSRAM IC required for UXGA resolution and high JPEG quality // Ensure ESP32 Wrover Module or other board with PSRAM is selected // Partial images will be transmitted if image exceeds buffer size // const char* ssid = "моя айди";//your id const char* password = "моя пароль";//your password char nul = 0; char serial_buf[2]; #define PWDN_GPIO_NUM 32 #define RESET_GPIO_NUM -1 #define XCLK_GPIO_NUM 0 #define SIOD_GPIO_NUM 26 #define SIOC_GPIO_NUM 27 #define Y9_GPIO_NUM 35 #define Y8_GPIO_NUM 34 #define Y7_GPIO_NUM 39 #define Y6_GPIO_NUM 36 #define Y5_GPIO_NUM 21 #define Y4_GPIO_NUM 19 #define Y3_GPIO_NUM 18 #define Y2_GPIO_NUM 5 #define VSYNC_GPIO_NUM 25 #define HREF_GPIO_NUM 23 #define PCLK_GPIO_NUM 22 //void startCameraServer(); typedef struct { size_t size; //number of values used for filtering size_t index; //current value index size_t count; //value count int sum; int * values; //array to be filled with values } ra_filter_t; typedef struct { httpd_req_t *req; size_t len; } jpg_chunking_t; #define PART_BOUNDARY "123456789000000000000987654321" static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY; static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n"; static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n"; static ra_filter_t ra_filter; httpd_handle_t stream_httpd = NULL; httpd_handle_t camera_httpd = NULL; static mtmn_config_t mtmn_config = {0}; static int8_t detection_enabled = 0; static int8_t recognition_enabled = 0; static int8_t is_enrolling = 0; static face_id_list id_list = {0}; static ra_filter_t * ra_filter_init(ra_filter_t * filter, size_t sample_size){ memset(filter, 0, sizeof(ra_filter_t)); filter->values = (int *)malloc(sample_size * sizeof(int)); if(!filter->values){ return NULL; } memset(filter->values, 0, sample_size * sizeof(int)); filter->size = sample_size; return filter; } static int ra_filter_run(ra_filter_t * filter, int value){ if(!filter->values){ return value; } filter->sum -= filter->values[filter->index]; filter->values[filter->index] = value; filter->sum += filter->values[filter->index]; filter->index++; filter->index = filter->index % filter->size; if (filter->count < filter->size) { filter->count++; } return filter->sum / filter->count; } static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){ jpg_chunking_t *j = (jpg_chunking_t *)arg; if(!index){ j->len = 0; } if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){ return 0; } j->len += len; return len; } static esp_err_t capture_handler(httpd_req_t *req){ // 4 пикселя для расчета оператора робертса byte x0y0; byte x1y0; byte x0y1; byte x1y1; camera_fb_t * fb = NULL; esp_err_t res = ESP_OK; int64_t fr_start = esp_timer_get_time(); fb = esp_camera_fb_get(); if (!fb) { Serial.println("Camera capture failed"); httpd_resp_send_500(req); return ESP_FAIL; } httpd_resp_set_type(req, "image/jpeg"); httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg"); httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*"); size_t out_len, out_width, out_height; uint8_t * out_buf; bool s; bool detected = false; int face_id = 0; dl_matrix3du_t *image_matrix = dl_matrix3du_alloc(1, fb->width, fb->height, 3); if (!image_matrix) { esp_camera_fb_return(fb); Serial.println("dl_matrix3du_alloc failed"); httpd_resp_send_500(req); return ESP_FAIL; } out_buf = image_matrix->item; out_len = fb->width * fb->height * 3; out_width = fb->width; out_height = fb->height; s = fmt2rgb888(fb->buf, fb->len, fb->format, out_buf); esp_camera_fb_return(fb); if(!s){ dl_matrix3du_free(image_matrix); Serial.println("to rgb888 failed"); httpd_resp_send_500(req); return ESP_FAIL; }else{ //проход по всем пикселям кроме последних по строкам и столбцам и расчет оператора робертса for(int i=0;i<out_height-1;i++){ for(int j=0;j<out_width-1;j++){ x0y0 = (byte)(out_buf[(j+i*out_width)*3] + out_buf[(j+i*out_width)*3+1] + out_buf[(j+i*out_width)*3+2])/3; x1y0 = (byte)(out_buf[(j+1+i*out_width)*3] + out_buf[(j+1+i*out_width)*3+1] + out_buf[(j+1+i*out_width)*3+2])/3; x0y1 = (byte)(out_buf[(j+(i+1)*out_width)*3] + out_buf[(j+(i+1)*out_width)*3+1] + out_buf[(j+(i+1)*out_width)*3+2])/3; x1y1 = (byte)(out_buf[(j+1+(i+1)*out_width)*3] + out_buf[(j+1+(i+1)*out_width)*3+1] + out_buf[(j+1+(i+1)*out_width)*3+2])/3; out_buf[(j+i*out_width)*3] = (byte)((x0y0>x1y1?x0y0-x1y1:x1y1-x0y0)+(x1y0>x0y1?x1y0-x0y1:x0y1-x1y0)); out_buf[(j+i*out_width)*3+1] = out_buf[(j+i*out_width)*3]; out_buf[(j+i*out_width)*3+2] = out_buf[(j+i*out_width)*3]; } } } jpg_chunking_t jchunk = {req, 0}; s = fmt2jpg_cb(out_buf, out_len, out_width, out_height, PIXFORMAT_RGB888, 90, jpg_encode_stream, &jchunk); dl_matrix3du_free(image_matrix); if(!s){ Serial.println("JPEG compression failed"); return ESP_FAIL; } int64_t fr_end = esp_timer_get_time(); Serial.printf("FACE: %uB %ums %s%d\n", (uint32_t)(jchunk.len), (uint32_t)((fr_end - fr_start)/1000), detected?"DETECTED ":"", face_id); return res; } static esp_err_t stream_handler(httpd_req_t *req){ camera_fb_t * fb = NULL; esp_err_t res = ESP_OK; size_t _jpg_buf_len = 0; uint8_t * _jpg_buf = NULL; char * part_buf[64]; dl_matrix3du_t *image_matrix = NULL; bool detected = false; int face_id = 0; int64_t fr_start = 0; int64_t fr_ready = 0; int64_t fr_face = 0; int64_t fr_recognize = 0; int64_t fr_encode = 0; static int64_t last_frame = 0; if(!last_frame) { last_frame = esp_timer_get_time(); } res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE); if(res != ESP_OK){ return res; } httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*"); while(true){ detected = false; face_id = 0; fb = esp_camera_fb_get(); if (!fb) { Serial.println("Camera capture failed"); res = ESP_FAIL; } else { fr_start = esp_timer_get_time(); fr_ready = fr_start; fr_face = fr_start; fr_encode = fr_start; fr_recognize = fr_start; if(!detection_enabled || fb->width > 400){ if(fb->format != PIXFORMAT_JPEG){ bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len); esp_camera_fb_return(fb); fb = NULL; if(!jpeg_converted){ Serial.println("JPEG compression failed"); res = ESP_FAIL; } } else { _jpg_buf_len = fb->len; _jpg_buf = fb->buf; } } else { image_matrix = dl_matrix3du_alloc(1, fb->width, fb->height, 3); if (!image_matrix) { Serial.println("dl_matrix3du_alloc failed"); res = ESP_FAIL; } else { if(!fmt2rgb888(fb->buf, fb->len, fb->format, image_matrix->item)){ Serial.println("fmt2rgb888 failed"); res = ESP_FAIL; } else { } dl_matrix3du_free(image_matrix); } } } if(res == ESP_OK){ res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY)); } if(res == ESP_OK){ size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len); res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen); } if(res == ESP_OK){ res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len); } if(fb){ esp_camera_fb_return(fb); fb = NULL; _jpg_buf = NULL; } else if(_jpg_buf){ free(_jpg_buf); _jpg_buf = NULL; } if(res != ESP_OK){ break; } int64_t fr_end = esp_timer_get_time(); int64_t ready_time = (fr_ready - fr_start)/1000; int64_t face_time = (fr_face - fr_ready)/1000; int64_t recognize_time = (fr_recognize - fr_face)/1000; int64_t encode_time = (fr_encode - fr_recognize)/1000; int64_t process_time = (fr_encode - fr_start)/1000; int64_t frame_time = fr_end - last_frame; last_frame = fr_end; frame_time /= 1000; uint32_t avg_frame_time = ra_filter_run(&ra_filter, frame_time); } last_frame = 0; return res; } static esp_err_t cmd_handler(httpd_req_t *req){ char* buf; size_t buf_len; char variable[32] = {0,}; char value[32] = {0,}; buf_len = httpd_req_get_url_query_len(req) + 1; if (buf_len > 1) { buf = (char*)malloc(buf_len); if(!buf){ httpd_resp_send_500(req); return ESP_FAIL; } if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) { if (httpd_query_key_value(buf, "var", variable, sizeof(variable)) == ESP_OK && httpd_query_key_value(buf, "val", value, sizeof(value)) == ESP_OK) { } else { free(buf); httpd_resp_send_404(req); return ESP_FAIL; } } else { free(buf); httpd_resp_send_404(req); return ESP_FAIL; } free(buf); } else { httpd_resp_send_404(req); return ESP_FAIL; } int val = atoi(value); sensor_t * s = esp_camera_sensor_get(); int res = 0; if(!strcmp(variable, "led")) { pinMode(4,OUTPUT); digitalWrite(4,!digitalRead(4)); } else { res = -1; } if(res){ return httpd_resp_send_500(req); } httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*"); return httpd_resp_send(req, NULL, 0); } static esp_err_t index_handler(httpd_req_t *req){ httpd_resp_set_type(req, "text/html"); httpd_resp_set_hdr(req, "Content-Encoding", "html"); sensor_t * s = esp_camera_sensor_get(); return httpd_resp_sendstr(req, (const char *)"<html><head><meta charset=\"Windows-1251\"><meta name=\"viewport\" content=\"user-scalable=no, width=device-width, initial-scale=1.0\" /><meta name=\"apple-mobile-web-app-capable\" content=\"yes\" />\ <style>body{overflow:hidden;width:100%;}</style>\ </head><body> \ <img src=\"capture\">\ <br> <button id=\"captureon\">capture</button>\ <br> <button id=\"ledon\">led toggle</button>\ <br> <a href=\"capture\">photo</a>\ <script>document.addEventListener('DOMContentLoaded', function (event) {var baseHost=document.location.origin; var streamUrl=baseHost+':81'; \ function sendCommand(el,val){fetch(baseHost+'/control?var='+el+'&val='+val);} \ document.getElementById('ledon').addEventListener('click',function(){ sendCommand('led',1); }); \ document.getElementById('captureon').addEventListener('click',function(){ document.images[0].src='capture?'+Math.random(); }); \ });</script>\ </body></html>"); } void startCameraServer(){ httpd_config_t config = HTTPD_DEFAULT_CONFIG(); httpd_uri_t index_uri = { .uri = "/", .method = HTTP_GET, .handler = index_handler, .user_ctx = NULL }; httpd_uri_t cmd_uri = { .uri = "/control", .method = HTTP_GET, .handler = cmd_handler, .user_ctx = NULL }; httpd_uri_t capture_uri = { .uri = "/capture", .method = HTTP_GET, .handler = capture_handler, .user_ctx = NULL }; httpd_uri_t stream_uri = { .uri = "/stream", .method = HTTP_GET, .handler = stream_handler, .user_ctx = NULL }; ra_filter_init(&ra_filter, 20); mtmn_config.type = FAST; mtmn_config.min_face = 80; mtmn_config.pyramid = 0.707; mtmn_config.pyramid_times = 4; mtmn_config.p_threshold.score = 0.6; mtmn_config.p_threshold.nms = 0.7; mtmn_config.p_threshold.candidate_number = 20; mtmn_config.r_threshold.score = 0.7; mtmn_config.r_threshold.nms = 0.7; mtmn_config.r_threshold.candidate_number = 10; mtmn_config.o_threshold.score = 0.7; mtmn_config.o_threshold.nms = 0.7; mtmn_config.o_threshold.candidate_number = 1; face_id_init(&id_list, FACE_ID_SAVE_NUMBER, ENROLL_CONFIRM_TIMES); Serial.printf("Starting web server on port: '%d'\n", config.server_port); if (httpd_start(&camera_httpd, &config) == ESP_OK) { httpd_register_uri_handler(camera_httpd, &index_uri); httpd_register_uri_handler(camera_httpd, &cmd_uri); httpd_register_uri_handler(camera_httpd, &capture_uri); } config.server_port += 1; config.ctrl_port += 1; Serial.printf("Starting stream server on port: '%d'\n", config.server_port); if (httpd_start(&stream_httpd, &config) == ESP_OK) { httpd_register_uri_handler(stream_httpd, &stream_uri); } } void setup() { Serial.begin(115200); Serial.setDebugOutput(true); Serial.println(); camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM; config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM; config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM; config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM; config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM; config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM; config.pin_sscb_sda = SIOD_GPIO_NUM; config.pin_sscb_scl = SIOC_GPIO_NUM; config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM; config.xclk_freq_hz = 20000000; config.pixel_format = PIXFORMAT_JPEG; // if PSRAM IC present, init with UXGA resolution and higher JPEG quality // for larger pre-allocated frame buffer. if(psramFound()){ config.frame_size = FRAMESIZE_UXGA; config.jpeg_quality = 10; config.fb_count = 2; } else { config.frame_size = FRAMESIZE_SVGA; config.jpeg_quality = 12; config.fb_count = 1; } // camera init esp_err_t err = esp_camera_init(&config); if (err != ESP_OK) { Serial.printf("Camera init failed with error 0x%x", err); return; } sensor_t * s = esp_camera_sensor_get(); // drop down frame size for higher initial frame rate s->set_framesize(s, FRAMESIZE_QVGA); //WiFi.begin(ssid, password); //while (WiFi.status() != WL_CONNECTED) { // delay(500); // Serial.print("."); //} //Serial.println(""); //Serial.println("WiFi connected"); WiFi.softAP(ssid, password); IPAddress IP = WiFi.softAPIP(); Serial.print("AP IP address: "); Serial.println(IP); startCameraServer(); Serial.print("Camera Ready! Use 'http://"); Serial.print(WiFi.localIP()); Serial.println("' to connect"); } void loop() { // put your main code here, to run repeatedly: }

Данный код является переделкой примера который скачивается вместе с библиотекой для данного модуля для среды Arduino. Код длинный а его полный разбор будет ещё длиннее поэтому лучше сосредоточиться на более интересных вещах. А разбор работы именно с аппаратными возможностями данного модуля, возможно будут выделены в отдельные статьи в данном блоге. Код алгоритма Робертса помещен в функцию capture_handler т.к. она вызывается после того как делается снимок, который можно разобрать на пиксели и обработать данным алгоритмом, после чего отправить результат по WIFI для просмотра на каком либо устройстве типа смартфона. Для того чтобы не было необходимости в роутере для получения результата. Добавлена возможность работы модуля в режиме точки доступа. В переменную ssid нужно записать название WIFI сети которую создаст модуль и к которой нужно будет подключиться для получения результата. В переменную password нужно записать пароль который нужно будет ввести при подключении к WIFI сети которую создаст модуль. IP адрес который нужно будет ввести в адресной строке браузера, после подключения к сети, можно посмотреть в мониторе последовательного порта среды Arduino IDE после запуска которого на модуле нужно будет нажать кнопку "reset" (единственная кнопка которая имеется на данном модуле) чтобы этот адрес появился. Модуль, при этом, должен быть подключен к компьютеру через usb-uart переходник. Схему такого подключения а также то как загрузить скетчь в данный модуль, можно посмотреть на странице  https://electe.blogspot.com/2022/03/esp32-cam.html. 

В функцию cmd_handler можно добавить возможность включать и выключать светодиод чтобы влиять на способность модуля распознавать границы объектов путем изменения освещения этих объектов остальные возможности из этой функции можно удалить чтобы  не занимали место в коде и не заставляли тратить много времени на его вертикальный скролинг.

В функции index_handler нужно найти вызов функции httpd_resp_set_hdr и поменять там строку GZIP на html чтобы можно было делать клиентскую часть на обычном html не конвертируя его в GZIP это удобнее и к томуже GZIP имеет меньший размер чем html только при больших размерах кода, при малых получается обратный эффект. Строка с HTML кодом клиентской части передается вторым параметром в функцию httpd_resp_sendstr. Чтобы текст можно было продолжить на следующей строке, можно ставить разделители обратные слеши. На фронтэнде т.е. клиентской стороне будет картинка с результатом обработки фотографии, кнопка чтобы сделать фотографию и выполнить обработку, кнопка чтобы включить/выключить освещение светодиодом и ссылка для перехода на страницу с результатом обработки фотографии. Также видно что в коде есть конструкция для того чтобы картинка бралась из сервера а не из кэша.

Алгоритм робертса в функции capture_handler будет реализовываться только в случае успешной конвертации фотографии в формат RGB888. Изображение состоит из пикселей, пиксель состоит из 3х составляющих красной, зеленой и синей на каждую состаляющую выделено 8 байт если усреднить составляющие то можно получить черно-белое изображение в данной реализации это делается на каждой итерации цикла для 4х соседних пикселей поэтому циклы проходят по всем пикселям кроме тех что в последней строке и последнем столбце для определения границы из правого нижнего пикселя вычитается левый верхний и из этой разницы берется модуль. Далее тоже самое производиться с оставшимися диагональными пикселями. Если берется модуль то, на самом деле, не важно какой из какого вычитаются главное чтобы это вычитание было перекресным в данной же реализации используется тренарный оператор для большей переносимости кода. После чего эти разницы по модулю складываются и получается результат, чем светлее пиксель тем резче переход цветов. Вот примерно такие получаются результаты обработки фотографий данным модулем с данным скетчем:

Это результаты обработки фотографий после усреднения всех пикселей, результаты обработки по пикселям каждой компоненты выглядят немного по другому и если присмотреться то можно увидеть отдельные цвета но в целом видно что в основном компоненты складываясь дают, как бы, просто переход по уровню яркоти:

Посмотреть результат работы также можно на видео:

КАРТА БЛОГА (содержание)