Diseño de interfaz de reconocimiento facial basado en GTK bajo Linux
1. Introducción al reconocimiento facial
El reconocimiento facial es una tecnología biométrica para la identificación basada en información de rasgos faciales humanos. Una serie de tecnologías relacionadas que utilizan una cámara de video o una cámara para recopilar imágenes o secuencias de video que contienen rostros humanos, detectan y rastrean automáticamente rostros humanos en las imágenes y luego realizan reconocimiento facial en los rostros detectados, generalmente también llamado reconocimiento de retrato y reconocimiento facial. . .
La investigación sobre el sistema de reconocimiento facial comenzó en la década de 1960. Después de la década de 1980, se mejoró con el desarrollo de la tecnología informática y la tecnología de imágenes ópticas, y realmente entró en la etapa de aplicación primaria a fines de la década de 1990. La implementación de la tecnología es el enfoque principal; la clave del éxito del sistema de reconocimiento facial es si tiene un algoritmo central de vanguardia, y el resultado del reconocimiento tiene una tasa de reconocimiento práctica y una velocidad de reconocimiento; el "sistema de reconocimiento facial" integra inteligencia artificial, reconocimiento automático, aprendizaje automático, teoría de modelos, sistema experto, procesamiento de imágenes de video y otras tecnologías profesionales, y al mismo tiempo necesita combinar la teoría y la implementación del procesamiento de valor intermedio.
El reconocimiento facial de IA es una tecnología biométrica que reconoce automáticamente a las personas en función de sus rasgos faciales (como rasgos estadísticos o geométricos, etc.), también conocido como reconocimiento facial, reconocimiento de retratos, reconocimiento facial, reconocimiento facial, espera de reconocimiento facial.
2. Reconocimiento facial Baidu AI
Inteligencia Artificial (Artificial Intelligence), la abreviatura en inglés es AI. Es una nueva ciencia técnica que estudia y desarrolla teorías, métodos, tecnologías y sistemas de aplicación para simular, extender y expandir la inteligencia humana.
La inteligencia artificial es una rama de la informática que intenta comprender la esencia de la inteligencia y producir una nueva máquina inteligente que pueda responder de manera similar a la inteligencia humana. La investigación en este campo incluye robótica, reconocimiento de lenguaje, reconocimiento de imágenes, procesamiento de lenguaje natural y sistemas expertos, etc Desde el nacimiento de la inteligencia artificial, la teoría y la tecnología se han vuelto cada vez más maduras, y los campos de aplicación también han seguido expandiéndose. Se puede imaginar que los productos tecnológicos traídos por la inteligencia artificial en el futuro serán el "contenedor" de la sabiduría humana. . La inteligencia artificial puede simular el proceso de información de la conciencia y el pensamiento humanos. La inteligencia artificial no es inteligencia humana, pero puede pensar como seres humanos y puede superar a la inteligencia humana.
La tecnología de reconocimiento facial de Baidu puede lograr un reconocimiento de alta precisión 1: N. Esta barrera técnica le permite a Baidu obtener ventajas técnicas únicas en el campo de las puertas frontales en lugares escénicos, grandes empresas y edificios de oficinas.
Hoy en día, con la promoción y popularización de la tecnología de reconocimiento facial en todos los ámbitos de la vida, los escenarios de aplicación se han vuelto más complejos y diversos, y los medios de los ataques de la industria negra también se han vuelto más engañosos. Con este fin, la solución de autenticación de nombre real facial de Baidu ha agregado capacidades de detección de imágenes sintéticas para identificar profundamente rastros falsificados en las imágenes, lo que hace que las imágenes PS, deepfake y otros ataques de imágenes sintéticas sean invisibles; se lanza la capacidad de control de riesgos de big data, basada en la enorme capacidad de Baidu big data El factor del dispositivo juzga e intercepta el riesgo del entorno del dispositivo en el lado del SDK; al mismo tiempo, con la capacidad de cifrado de seguridad, la información facial se cifra en el lado del SDK y la interfaz de la nube la descifra para evitar productos negros. de falsificar y reemplazar durante el proceso de carga de información a la nube.
- Introducción a la función:
- Admite la comparación de similitudes entre dos imágenes de caras: compare la similitud de las caras en dos imágenes y devuelva la puntuación de similitud.
- Múltiples tipos de imágenes: Admite cuatro tipos de comparaciones de caras: fotos de vida, fotos de identificación, fotos de chip de tarjeta de identificación y fotos de malla.
- Control de detección de vida: según el análisis de los defectos en la imagen, se juzga si la cara en ella es una nueva versión (por ejemplo: si el usuario A usa un teléfono móvil para tomar una foto que contiene una cara, el usuario B toma la foto 1 y obtiene la imagen 2, y usa la imagen 2 para hacerse pasar por el usuario A para realizar operaciones de identificación, que generalmente ocurren en la apertura de cuentas financieras, autenticación de nombre real, etc.).
- Inspección y control de calidad: analice el desenfoque, el ángulo, la intensidad de la luz y otras características del rostro en la imagen para juzgar la calidad de la imagen.
- Detección de vida basada en imágenes: en función de una sola imagen, se juzga si la cara de la imagen es una segunda nueva versión (por ejemplo: si el usuario A usa un teléfono móvil para tomar una foto que contiene una cara, el usuario B vuelve a hacer la imagen y obtiene la imagen En segundo lugar, use la imagen 2 para hacerse pasar por el usuario A para realizar operaciones de identificación, lo que generalmente ocurre en la apertura de cuentas financieras, autenticación de nombre real, etc.) y si se trata de un ataque de imagen sintética. Esta capacidad se puede utilizar en algunos escenarios de recopilación de rostros en escenarios H5 para aumentar la seguridad y la autenticidad del registro de rostros.
3. Aplicación
3.1 Puerta de reconocimiento facial
Detección de vida local (vida local): al permitir que los usuarios realicen acciones de interacción facial específicas, puede identificar si el operador actual está vivo. Esta función se puede usar sin conexión y puede establecer si usar las acciones especificadas y la secuencia de la aplicación. Puede resistir eficazmente ataques como imágenes de alta definición, modelado 3D y videos.
Detección de vida en línea (vida en línea): en función de las imágenes calificadas de calidad emitidas por la versión local con detección de vida interactiva, solicite la interfaz de detección de vida en línea, que puede juzgar aún más si la imagen cargada por el usuario está viva y resiste más alto -video de precisión y modelado de alta precisión Espere el ataque. Se recomienda utilizar esta interfaz junto con la versión local de detección de vida, y la foto de entrada debe ser una imagen de colección secundaria (es decir, se limita a la foto tomada por la parte frontal del producto y no puede ser una imagen del álbum).
Detección de la calidad de la cara: determine cuál de los cuadros de la transmisión de video tiene mejor calidad, es decir, las características de la imagen de la cara son claras (satisfaciendo la verificación del ángulo, la postura, la iluminación, el desenfoque, etc.).
Reconocimiento facial: un término general para la tecnología de reconocimiento facial, que generalmente se refiere al reconocimiento de rostros en imágenes o videos, la extracción de valores de características faciales para una mayor comparación de rostros, búsqueda y otras operaciones comerciales.
3.2 Asistencia presencial
En comparación con la asistencia tradicional de registro de entrada y la asistencia de huellas dactilares, la asistencia presencial tiene muchas ventajas:
(1) Gran capacidad anti-trampas: proporciona soluciones de detección de cuerpos vivos en línea y fuera de línea, que pueden resistir eficazmente los métodos de trampa de cuerpos vivos como videos, remakes, y modelos 3D.
(2) Admite que varias personas verifiquen la asistencia al mismo tiempo: la cámara inteligente admite la captura simultánea de varias caras que aparecen en la transmisión de video, lo que permite que varias personas verifiquen la asistencia al mismo tiempo y mejoren la eficiencia de la asistencia.
(3) Respuesta rápida: 500 milisegundos para reconocimiento y comparación rápidos, y todo el proceso de captura de rostros y asistencia se puede completar en 2 segundos.
3.3 Detección y reconocimiento de mascarillas
Con el fin de garantizar y promover la rápida reanudación del trabajo, la producción y la escuela, Baidu Smart Cloud lanzó un modelo de detección de uso de máscaras y, al mismo tiempo, optimizó el algoritmo de reconocimiento facial cuando la cara que usa una máscara está cubierta por un área grande. En la actualidad, la capacidad de prueba de máscaras ha cubierto todas las formas de productos, y estará abierta al público para su uso a partir de ahora para ayudar a prevenir y controlar la epidemia y garantizar el desarrollo ordenado de la reanudación del trabajo, la producción y la escuela.
Hay dos aspectos principales de las capacidades de detección y reconocimiento de máscaras faciales, a saber, la detección de máscaras y el reconocimiento facial con máscaras.
Detección de mascarilla: Se utiliza para juzgar y clasificar si el usuario lleva mascarilla o no. Esta capacidad es adecuada para escenarios de aplicaciones que necesitan clasificar y controlar a las personas en función de si usan máscaras, como lugares públicos grandes como aeropuertos, estaciones, hospitales y supermercados.
Reconocimiento facial mientras se usa una máscara: se utiliza para el reconocimiento facial cuando se usa una máscara, es decir, el usuario puede completar la detección de rostros, detección de vida, extracción de características y comparación sin quitarse la máscara, para realizar la verificación de identidad. Esta capacidad es aplicable a escenarios de aplicación como puertas de control de acceso de varias empresas, comunidades y edificios de oficinas, y máquinas de asistencia de la empresa.
4. Ambiente de desarrollo y efecto de operación.
Plataforma de hardware: Ubuntu18.04, cámara sin controlador USB
Interfaz de interfaz de usuario: GTK+_2.0
Lenguaje de desarrollo: C/C++
5. Introducción a GTK
GTK (GIMP Toolkit) es un conjunto de herramientas de gráficos multiplataforma cuyo código fuente se distribuye bajo la licencia LGPL. Originalmente escrito para GIMP, se ha convertido en una biblioteca de gráficos de uso general con funciones potentes y diseño flexible.Es una de las principales herramientas de desarrollo para desarrollar aplicaciones de interfaz gráfica bajo GNU/Linux. Por supuesto, GTK también es compatible con plataformas cruzadas, sistemas similares a Unix, Windows e incluso plataformas de teléfonos móviles.
GTK está escrito en lenguaje C, por lo que sus API nativas están todas orientadas a C. Al mismo tiempo, una característica importante de GTK es que implementa funciones orientadas a objetos en el nivel de lenguaje C. GTK es completamente gratuito y se basa en el acuerdo LGPL, que garantiza que el software privado pueda usar GTK a través de enlaces sin abrir el código fuente del software, lo que es más amigable para las aplicaciones comerciales, que es diferente del acuerdo GPL. También es el acuerdo LGPL lo que hizo que Gnome (escrito en base a GTK) superara a KDE (escrito en base a QT) en los primeros años.
6. Proceso de desarrollo
6.1 Inicialización de GTK e inicialización de cámara
Inicialice GTK, cree una ventana, inicialice el dispositivo de la cámara y verifique si el dispositivo de la cámara es normal.
int main(int argc,char **argv)
{
GtkWidget *dialog;
/*gtk初始化*/
gtk_init(&argc,&argv);
/*创建窗口*/
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"人脸识别");
/*固定窗口大小*/
gtk_window_set_resizable (GTK_WINDOW(window),FALSE);
/*设置窗口大小*/
gtk_widget_set_size_request(window,800,480);
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER_ALWAYS);//居中显示
/*连接信号*/
g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(on_delete_event),NULL);
/*创建标签*/
GdkColor color;
color.red=0xffff;
color.green=0;
color.blue=0;
label=gtk_label_new("");
/*设置字体大小和颜色*/
gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='32'>正在启动摄像头，请稍等...</span>");
g_timeout_add(500,timer_func, label);//开启定时器1s时间
gtk_label_set_justify (GTK_LABEL(label),GTK_JUSTIFY_CENTER);
gtk_container_add(GTK_CONTAINER(window), label);
gtk_widget_show(label);
change_background(window, 800, 480, "1.bmp");
gtk_widget_show(window);
gtk_main();
return 0;
}
Espere a que la cámara se inicie correctamente en el temporizador y complete la configuración de la interfaz de usuario de reconocimiento facial.
- Espere a que la cámara inicie la interfaz
- Interfaz de éxito de inicio de cámara
/*定时器处理函数*/
GtkWidget *window;
gboolean timer_func(gpointer data)
{
GtkWidget *widget=(GtkWidget *)data;
int ret;
ret=Camera_Init(&video_info);
if(ret==0)
{
g_print("摄像头启动成功\n");
gtk_widget_destroy(label);//关闭对话框
GtkWidget *hbox;
GtkWidget *vbox,*box;
GtkWidget *button;
GtkTooltips *tiptool;
/*图像宽高*/
width=video_info.image_w;
height=video_info.image_h;
rgbbuf=malloc(width*height*3);
jpg_data=malloc(width*height*3);//保存RGB颜色数据
imagebase64_data=malloc((height*width*3)*8/6);/*base64编码后数据*/
/*创建横向盒*/
hbox=gtk_hbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window),hbox);
gtk_widget_show(hbox);
/*初始化gdk的rgb*/
gdk_rgb_init();
/*将gdk视件和颜色表放入gtk构件中*/
gtk_widget_push_visual(gdk_rgb_get_visual());
gtk_widget_push_colormap(gdk_rgb_get_cmap());
/*创建绘图区域*/
drawarea=gtk_drawing_area_new();
gtk_widget_pop_visual();
gtk_widget_pop_colormap();
gtk_box_pack_start(GTK_BOX(hbox),drawarea,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(drawarea),"expose_event",G_CALLBACK(draw_image),NULL);
guint id=gtk_idle_add((GtkFunction)read_data,NULL);
/*设置窗口大小*/
gtk_widget_set_size_request(GTK_WIDGET(drawarea),width,height);
/*创建纵向盒*/
vbox=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox),vbox,TRUE,FALSE,0);
gtk_widget_show(vbox);
/*人脸注册时输入姓名*/
box=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),box,FALSE,TRUE,30);
gtk_widget_show(box);
label=gtk_label_new("姓名:");
gtk_box_pack_start(GTK_BOX(box),label,FALSE,TRUE,0);
gtk_widget_show(label);
/*创建输入文本框*/
entry1=gtk_entry_new();
/*设置输入文本框尺寸*/
gtk_widget_set_size_request(entry1,120,-1);
gtk_entry_set_max_length(GTK_ENTRY(entry1),20);
gtk_box_pack_start(GTK_BOX(box),entry1,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(entry1),"key-press-event", G_CALLBACK(entry_callback),"1");
gtk_widget_show(entry1);
/*创建提示对象工具*/
tiptool=gtk_tooltips_new();
/*添加提示信息到按钮*/
gtk_tooltips_set_tip(tiptool,entry1,"填写姓名",NULL);
/*人脸注册时输入手机号*/
box=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),box,FALSE,TRUE,15);
gtk_widget_show(box);
label=gtk_label_new("电话:");
gtk_box_pack_start(GTK_BOX(box),label,FALSE,TRUE,0);
gtk_widget_show(label);
/*创建输入文本框*/
entry2=gtk_entry_new();
/*设置输入文本框尺寸*/
gtk_widget_set_size_request(entry2,120,-1);
gtk_entry_set_max_length(GTK_ENTRY(entry2),20);
gtk_box_pack_start(GTK_BOX(box),entry2,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(entry2),"key-press-event", G_CALLBACK(entry_callback),"2");
gtk_widget_show(entry2);
/*创建提示对象工具*/
tiptool=gtk_tooltips_new();
/*添加提示信息到按钮*/
gtk_tooltips_set_tip(tiptool,entry2,"填写手机号",NULL);
/*设置标签，用于显示状态信息*/
box=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),box,FALSE,FALSE,80);
gtk_widget_show(box);
label=gtk_label_new("");
gtk_label_set_justify (GTK_LABEL(label),GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(box),label,TRUE,FALSE,20);
gtk_widget_show(label);
box=gtk_hbox_new(FALSE,0);
gtk_box_pack_end(GTK_BOX(vbox),box,FALSE,FALSE,20);
gtk_widget_show(box);
button=gtk_button_new_with_label("人脸识别");
gtk_box_pack_start(GTK_BOX(box),button,TRUE,TRUE,0);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(button_callback),"1");
gtk_widget_show(button);
box=gtk_hbox_new(FALSE,0);
gtk_box_pack_end(GTK_BOX(vbox),box,FALSE,FALSE,20);
gtk_widget_show(box);
button=gtk_button_new_with_label("人脸注册");
gtk_box_pack_start(GTK_BOX(box),button,TRUE,TRUE,0);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(button_callback),"2");
gtk_widget_show(button);
gtk_widget_show_all(window);
return FALSE;//返回FALSE结束定时器
}
g_print("摄像头打开失败ret=%d\n",ret);
gtk_label_set_markup(GTK_LABEL(widget),"<span foreground='red' font_desc='20'>摄像头启动失败，请检测设备是否正常！</span>");
return TRUE;//返回TURE继续触发定时器
}
6.2 Reconocimiento facial y registro facial
Base64 codifica las imágenes capturadas por la cámara y luego llama a la interfaz AI de Baidu para el registro y la comparación de rostros.
1. Interfaz e introducción de Baidu Smart Cloud https://cloud.baidu.com/product/face
- Documentación técnica de la interfaz de reconocimiento facial AI
/*按钮处理函数*/
void button_callback(GtkWidget *widget,gpointer data)
{
gint res=0;
gchar format_data[512];
gchar *p=(gchar *)data;
guint size=(height*width*3)*8/6;
gchar *imagebase64=malloc(size);/*base64编码后数据*/
if(strcmp(p,"1"))//人脸注册
{
g_print("人脸注册\n");
/*保证线程安全，上锁*/
gdk_threads_enter();
memcpy(imagebase64,imagebase64_data,size);
/*保证线程安全，释放*/
gdk_threads_leave();
if(user_info.name[0]=='\0' || user_info.phone[0]=='\0' || strlen(user_info.phone)!=11)
{
//g_print("请正常填写名字手机号码\n");
gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='12'>请正常填写名字\n手机号码</span>");
//开启定时器1s时间
time_flag=g_timeout_add(1000,timer_func2,label);
free(imagebase64);
return ;
}
/*人脸注册*/
g_print("phone:%s,name:%s\n",user_info.phone,user_info.name);
snprintf(format_data,512,"\"group_id\":\"wbyq\",\"user_id\":\"%s\",\"user_info\":\"%s\",\"quality_control\":\"LOW\",\"liveness_control\":\"NORMAL\"}",user_info.phone,user_info.name);
g_print("format=%s\n",format_data);
faceDetect(request_url,access_token,imagebase64,format_data);
if(res)/*访问服务器失败*/
{
gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='20'>注册失败</span>");
}
/*
{"error_code":0,"error_msg":"SUCCESS","log_id":9465001899925,"timestamp":1641801995,"cached":0,"result":{"face_token":"66d2d1512ec57835ec4ef25ed95bec77",
"location":{"left":265.38,"top":251.49,"width":201,"height":192,"rotation":0}}}
*/
else if(JsonData_analysis(platform_data,"\"error_msg\"",format_data))/*查找“error_msg”标志失败*/
{
gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='20'>注册失败</span>");
}
else if(strcmp(format_data,"SUCCESS"))/*返回状态标志失败*/
{
gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='20'>注册失败</span>");
}
else gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='20'>注册成功</span>");
}
else if(strcmp(p,"2"))//人脸识别
{
if(time_flag)g_source_remove(time_flag);//关闭定时器
/*保证线程安全，上锁*/
gdk_threads_enter();
memcpy(imagebase64,imagebase64_data,size);
/*保证线程安全，释放*/
gdk_threads_leave();
snprintf(format_data,sizeof(format_data),"\"group_id_list\":\"wbyq\",\"quality_control\":\"LOW\",\"liveness_control\":\"NORMAL\"}");
res=faceDetect(face_search,access_token,imagebase64,format_data);//人脸比对
if(res==0)
{
struct USER user_data;
if(Josn_faceSearch(platform_data,&user_data))
{
//g_print("比对失败\n");
gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='20'>请重试</span>");
gtk_entry_set_text(GTK_ENTRY(entry1),"");
gtk_entry_set_text(GTK_ENTRY(entry2),"");
}
else
{
//g_print("比对成功:%s\n",format_data);
gtk_label_set_markup(GTK_LABEL(label),"<span foreground='red' font_desc='20'>识别成功</span>");
gtk_entry_set_text(GTK_ENTRY(entry1),user_data.name);
gtk_entry_set_text(GTK_ENTRY(entry2),user_data.phone);
}
}
}
free(imagebase64);
}
Codificación en formato 6.3 base64
Base64 es uno de los métodos de codificación más comunes para transmitir códigos de bytes de 8 bits en Internet Base64 es un método para representar datos binarios basado en 64 caracteres imprimibles. Puede consultar RFC2045~RFC2049, que tiene especificaciones detalladas de MIME.
La codificación Base64 es un proceso de binario a carácter, que se puede utilizar para transmitir información de identificación larga en el entorno HTTP. La codificación Base64 es ilegible y debe decodificarse antes de leer.
Debido a las ventajas anteriores, Base64 se usa ampliamente en varios campos de las computadoras. Sin embargo, dado que la salida contiene más de dos caracteres de "símbolo" (+, /, =), se han desarrollado varias "variantes" de Base64 para diferentes escenarios de aplicación. . . Para unificar y normalizar la salida de Base64, Base62x se considera una versión mejorada de unsigned.
Base64 requiere convertir cada tres bytes de 8 bits en cuatro bytes de 6 bits (3 8 = 4 6 = 24), y luego agregar dos 0 de orden alto a 6 bits para formar cuatro bytes de 8 bits, es decir, la cadena convertida teóricamente será 1/3 más larga que el original.
6.3.1 Ejemplo de codificación Base64
static const char * base64char = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
char * base64_encode( const unsigned char * bindata, char * base64, int binlength )
{
int i, j;
unsigned char current;
for ( i = 0, j = 0 ; i < binlength ; i += 3 )
{
current = (bindata[i] >> 2) ;
current &= (unsigned char)0x3F;
base64[j++] = base64char[(int)current];
current = ( (unsigned char)(bindata[i] << 4 ) ) & ( (unsigned char)0x30 ) ;
if ( i + 1 >= binlength )
{
base64[j++] = base64char[(int)current];
base64[j++] = '=';
base64[j++] = '=';
break;
}
current |= ( (unsigned char)(bindata[i+1] >> 4) ) & ( (unsigned char) 0x0F );
base64[j++] = base64char[(int)current];
current = ( (unsigned char)(bindata[i+1] << 2) ) & ( (unsigned char)0x3C ) ;
if ( i + 2 >= binlength )
{
base64[j++] = base64char[(int)current];
base64[j++] = '=';
break;
}
current |= ( (unsigned char)(bindata[i+2] >> 6) ) & ( (unsigned char) 0x03 );
base64[j++] = base64char[(int)current];
current = ( (unsigned char)bindata[i+2] ) & ( (unsigned char)0x3F ) ;
base64[j++] = base64char[(int)current];
}
base64[j] = '\0';
return base64;
}
6.3.2 ejemplo de decodificación base64
int base64_decode( const char * base64, unsigned char * bindata )
{
int i, j;
unsigned char k;
unsigned char temp[4];
for ( i = 0, j = 0; base64[i] != '\0' ; i += 4 )
{
memset( temp, 0xFF, sizeof(temp) );
for ( k = 0 ; k < 64 ; k ++ )
{
if ( base64char[k] == base64[i] )
temp[0]= k;
}
for ( k = 0 ; k < 64 ; k ++ )
{
if ( base64char[k] == base64[i+1] )
temp[1]= k;
}
for ( k = 0 ; k < 64 ; k ++ )
{
if ( base64char[k] == base64[i+2] )
temp[2]= k;
}
for ( k = 0 ; k < 64 ; k ++ )
{
if ( base64char[k] == base64[i+3] )
temp[3]= k;
}
bindata[j++] = ((unsigned char)(((unsigned char)(temp[0] << 2))&0xFC)) |
((unsigned char)((unsigned char)(temp[1]>>4)&0x03));
if ( base64[i+2] == '=' )
break;
bindata[j++] = ((unsigned char)(((unsigned char)(temp[1] << 4))&0xF0)) |
((unsigned char)((unsigned char)(temp[2]>>2)&0x0F));
if ( base64[i+3] == '=' )
break;
bindata[j++] = ((unsigned char)(((unsigned char)(temp[2] << 6))&0xF0)) |
((unsigned char)(temp[3]&0x3F));
}
return j;
}
6.4 Análisis de datos en formato CJSON
JSON (JavaScript Object Notation, JS Object Notation) es un formato de intercambio de datos ligero. Se basa en un subconjunto de ECMAScript (Asociación Europea de Fabricantes de Computadoras, la especificación js desarrollada por la Asociación Europea de Computadoras) y utiliza un formato de texto que es completamente independiente del lenguaje de programación para almacenar y representar datos. La simplicidad y la clara jerarquía hacen de JSON un lenguaje de intercambio de datos ideal. Es fácil de leer y escribir para las personas, y también es fácil de analizar y generar para las máquinas, y puede mejorar efectivamente la eficiencia de la transmisión de la red.
JSON es una secuencia de tokens. Este conjunto de tokens contiene seis caracteres construidos, cadenas, números y tres nombres literales.
JSON es un objeto o una matriz serializados.
- Ejemplo de análisis de datos en formato JSON
/******************json数据解析****************
形参：u8* buff原始数据
u8 *flag数据标志
u8 *data解析获取到的数据
返回值：0---成功，其他值---失败
************************************************/
guchar JsonData_analysis(guchar* buff,guchar *flag,guchar *data)
{
guchar *p=NULL;
guint i=0;
p=strstr((char *)buff,(char *)flag);
if(p)
{
p+=strlen((char *)flag)+2;
i=0;
while(*p!='\"' && *p!='\0')
{
data[i++]=*p++;
}
data[i]='\0';
return 0;
}
else return -1;
}
/*
josn数据解析
buff --要解析的内
user_info--解析成功返回用户名和id
返回值：成功返回0，失败返回其它值
*/
int Josn_faceSearch(const char *buff,struct USER *user_info)
{
/*
data={"error_code":0,"error_msg":"SUCCESS","log_id":2014555550012,"timestamp":1641792320,"cached":0,
"result":{"face_token":"6473abd658b76d6843de9a0820aeb2d2","user_list":[{"group_id":"wbyq","user_id":"18172864683","user_info":"\u738b\u65b0\u6c34","score":99.232490539551}]}}
*/
/*创建cJSON对象*/
cJSON *root=cJSON_CreateObject();
char *p=strstr(buff,"{\"error_code\"");
root=cJSON_Parse(p);/*载入JSON数据*/
if(root==NULL)return -1;
/*2.解析字段*/
cJSON *item;
item=cJSON_GetObjectItem(root,"error_msg");
if(item)
{
printf("error_code:%s\n",item->valuestring);
if(strcmp(item->valuestring,"SUCCESS"))return -2;
}
item=cJSON_GetObjectItem(root,"result");
if(item)
{
item=cJSON_GetObjectItem(item,"user_list");
cJSON *array_item=cJSON_GetArrayItem(item,0);
if(array_item==NULL)return -1;
cJSON *obj=cJSON_GetObjectItem(array_item,"user_info");
if(obj)printf("info=%s\n",obj->valuestring);
strcpy(user_info->name,obj->valuestring);
obj=cJSON_GetObjectItem(array_item,"user_id");
strcpy(user_info->phone,obj->valuestring);
}
cJSON_Delete(root);//释放空间
return 0;
}
7. Efecto de ejecución de reconocimiento facial y registro facial
Ejemplo de adquisición de imágenes de la cámara: https://blog.csdn.net/weixin_44453694/article/details/126488841