recognition_proc.cpp

00001 #include "mbed.h"
00002 #include "DisplayBace.h"
00003 #include "rtos.h"
00004 #include "AsciiFont.h"
00005 #include "USBHostSerial.h"
00006 #include "LCD_shield_config_4_3inch.h"
00007 #include "recognition_proc.h"
00008 
00009 #define UART_SETTING_TIMEOUT              1000            /* HVC setting command signal timeout period */
00010 #define UART_REGIST_EXECUTE_TIMEOUT       7000            /* HVC registration command signal timeout period */
00011 #define UART_EXECUTE_TIMEOUT              4000            /* HVC execute command signal timeout period */
00012 
00013 #define SENSOR_ROLL_ANGLE_DEFAULT            0            /* Camera angle setting (0属) */
00014 #define USER_ID_NUM_MAX                     10
00015 
00016 #define ERROR_02                         "Error: Number of detected faces is 2 or more"
00017 
00018 #define DISP_PIXEL_WIDTH                 (320)
00019 #define DISP_PIXEL_HEIGHT                (240)
00020 
00021 /*! Frame buffer stride: Frame buffer stride should be set to a multiple of 32 or 128
00022     in accordance with the frame buffer burst transfer mode. */
00023 /* FRAME BUFFER Parameter GRAPHICS_LAYER_0 */
00024 #define FRAME_BUFFER_BYTE_PER_PIXEL   (2u)
00025 #define FRAME_BUFFER_STRIDE           (((DISP_PIXEL_WIDTH * FRAME_BUFFER_BYTE_PER_PIXEL) + 31u) & ~31u)
00026 
00027 /* RESULT BUFFER Parameter GRAPHICS_LAYER_1 */
00028 #define RESULT_BUFFER_BYTE_PER_PIXEL  (2u)
00029 #define RESULT_BUFFER_STRIDE          (((DISP_PIXEL_WIDTH * RESULT_BUFFER_BYTE_PER_PIXEL) + 31u) & ~31u)
00030 
00031 static bool  registrationr_req = false;
00032 static bool  setting_req = false;
00033 static recognition_setting_t setting = {
00034     0,
00035     { BODY_THRESHOLD_DEFAULT, HAND_THRESHOLD_DEFAULT, FACE_THRESHOLD_DEFAULT, REC_THRESHOLD_DEFAULT},
00036     { BODY_SIZE_RANGE_MIN_DEFAULT, BODY_SIZE_RANGE_MAX_DEFAULT, HAND_SIZE_RANGE_MIN_DEFAULT,
00037       HAND_SIZE_RANGE_MAX_DEFAULT, FACE_SIZE_RANGE_MIN_DEFAULT, FACE_SIZE_RANGE_MAX_DEFAULT},
00038     FACE_POSE_DEFAULT,
00039     FACE_ANGLE_DEFAULT
00040 };
00041 static USBHostSerial serial;
00042 static InterruptIn button(USER_BUTTON0);
00043 
00044 #if defined(__ICCARM__)
00045 /* 32 bytes aligned */
00046 #pragma data_alignment=32
00047 static uint8_t user_frame_buffer0[FRAME_BUFFER_STRIDE * DISP_PIXEL_HEIGHT]@ ".mirrorram";
00048 #pragma data_alignment=32
00049 static uint8_t user_frame_buffer_result[RESULT_BUFFER_STRIDE * DISP_PIXEL_HEIGHT]@ ".mirrorram";
00050 #else
00051 /* 32 bytes aligned */
00052 static uint8_t user_frame_buffer0[FRAME_BUFFER_STRIDE * DISP_PIXEL_HEIGHT]__attribute((section("NC_BSS"),aligned(32)));
00053 static uint8_t user_frame_buffer_result[RESULT_BUFFER_STRIDE * LCD_PIXEL_HEIGHT]__attribute((section("NC_BSS"),aligned(32)));
00054 #endif
00055 
00056 static AsciiFont ascii_font(user_frame_buffer_result, DISP_PIXEL_WIDTH, LCD_PIXEL_HEIGHT,
00057                             RESULT_BUFFER_STRIDE, RESULT_BUFFER_BYTE_PER_PIXEL, 0x00000090);
00058 static INT32 imageNo_setting = HVC_EXECUTE_IMAGE_QVGA_HALF;
00059 static int str_draw_x = 0;
00060 static int str_draw_y = 0;
00061 
00062 #if(1) //mbed client
00063 extern void HVCSendData(char * addr, int size);
00064 
00065 static char send_cloud_buf[1024 * 4];
00066 #endif
00067 
00068 /****** Image Recognition ******/
00069 extern "C" int UART_SendData(int inDataSize, UINT8 *inData) {
00070     return serial.writeBuf((char *)inData, inDataSize);
00071 }
00072 
00073 extern "C" int UART_ReceiveData(int inTimeOutTime, int inDataSize, UINT8 *outResult) {
00074     return serial.readBuf((char *)outResult, inDataSize, inTimeOutTime);
00075 }
00076 
00077 void SetRegistrationrReq(void) {
00078     registrationr_req = true;
00079 }
00080 
00081 void SetSettingReq(void) {
00082     setting_req = true;
00083 }
00084 
00085 recognition_setting_t * GetRecognitionSettingPointer(void) {
00086     return &setting;
00087 }
00088 
00089 static void EraseImage(void) {
00090     uint32_t i = 0;
00091     while (i < sizeof(user_frame_buffer0)) {
00092         user_frame_buffer0[i++] = 0x10;
00093         user_frame_buffer0[i++] = 0x80;
00094     }
00095 }
00096 
00097 static void DrawImage(int x, int y, int nWidth, int nHeight, UINT8 *unImageBuffer, int magnification) {
00098     int idx_base;
00099     int idx_w = 0;
00100     int wk_tmp = 0;
00101     int i;
00102     int j;
00103     int k;
00104     int idx_r = 0;
00105 
00106     if (magnification <= 0) {
00107         return;
00108     }
00109 
00110     idx_base = (x + (DISP_PIXEL_WIDTH * y)) * RESULT_BUFFER_BYTE_PER_PIXEL;
00111 
00112     for (i = 0; i < nHeight; i++) {
00113         idx_w = idx_base + (DISP_PIXEL_WIDTH * RESULT_BUFFER_BYTE_PER_PIXEL * i) * magnification;
00114         wk_tmp = idx_w;
00115         for (j = 0; j < nWidth; j++) {
00116             for (k = 0; k < magnification; k++) {
00117                 user_frame_buffer0[idx_w] = unImageBuffer[idx_r];
00118                 idx_w += 2;
00119             }
00120             idx_r++;
00121         }
00122         for (k = 1; k < magnification; k++) {
00123             memcpy(&user_frame_buffer0[wk_tmp + (DISP_PIXEL_WIDTH * RESULT_BUFFER_BYTE_PER_PIXEL * k)], &user_frame_buffer0[wk_tmp], idx_w - wk_tmp);
00124         }
00125     }
00126 }
00127 
00128 static void DrawSquare(int x, int y, int size, uint32_t const colour) {
00129     int wk_x;
00130     int wk_y;
00131     int wk_w = 0;
00132     int wk_h = 0;
00133     int idx_base;
00134     int wk_idx;
00135     int i;
00136     int j;
00137     uint8_t coller_pix[RESULT_BUFFER_BYTE_PER_PIXEL];  /* ARGB4444 */
00138     bool l_draw = true;
00139     bool r_draw = true;
00140     bool t_draw = true;
00141     bool b_draw = true;
00142 
00143     if ((x - (size / 2)) < 0) {
00144         l_draw = false;
00145         wk_w += x;
00146         wk_x = 0;
00147     } else {
00148         wk_w += (size / 2);
00149         wk_x = x - (size / 2);
00150     }
00151 
00152     if ((x + (size / 2)) >= 1600) {
00153         r_draw = false;
00154         wk_w += (1600 - x);
00155     } else {
00156         wk_w += (size / 2);
00157     }
00158 
00159     if ((y - (size / 2)) < 0) {
00160         t_draw = false;
00161         wk_h += y;
00162         wk_y = 0;
00163     } else {
00164         wk_h += (size / 2);
00165         wk_y = y - (size / 2);
00166     }
00167 
00168     if ((y + (size / 2)) >= 1200) {
00169         b_draw = false;
00170         wk_h += (1200 - y);
00171     } else {
00172         wk_h += (size / 2);
00173     }
00174 
00175     wk_x = wk_x / 5;
00176     wk_y = wk_y / 5;
00177     wk_w = wk_w / 5;
00178     wk_h = wk_h / 5;
00179 
00180     if ((colour == 0x0000f0f0) || (colour == 0x0000fff4)) {
00181         str_draw_x = wk_x;
00182         str_draw_y = wk_y + wk_h + 1;
00183     }
00184 
00185     idx_base = (wk_x + (DISP_PIXEL_WIDTH * wk_y)) * RESULT_BUFFER_BYTE_PER_PIXEL;
00186 
00187     /* Select color */
00188     coller_pix[0] = (colour >> 8) & 0xff;  /* 4:Green 4:Blue */
00189     coller_pix[1] = colour & 0xff;         /* 4:Alpha 4:Red  */
00190 
00191     /* top */
00192     if (t_draw) {
00193         wk_idx = idx_base;
00194         for (j = 0; j < wk_w; j++) {
00195             user_frame_buffer_result[wk_idx++] = coller_pix[0];
00196             user_frame_buffer_result[wk_idx++] = coller_pix[1];
00197         }
00198     }
00199 
00200     /* middle */
00201     for (i = 1; i < (wk_h - 1); i++) {
00202         wk_idx = idx_base + (DISP_PIXEL_WIDTH * RESULT_BUFFER_BYTE_PER_PIXEL * i);
00203         if (l_draw) {
00204             user_frame_buffer_result[wk_idx + 0] = coller_pix[0];
00205             user_frame_buffer_result[wk_idx + 1] = coller_pix[1];
00206         }
00207         wk_idx += (wk_w - 1) * 2;
00208         if (r_draw) {
00209             user_frame_buffer_result[wk_idx + 0] = coller_pix[0];
00210             user_frame_buffer_result[wk_idx + 1] = coller_pix[1];
00211         }
00212     }
00213 
00214     /* bottom */
00215     if (b_draw) {
00216         wk_idx = idx_base + (DISP_PIXEL_WIDTH * RESULT_BUFFER_BYTE_PER_PIXEL * (wk_h - 1));
00217         for (j = 0; j < wk_w; j++) {
00218             user_frame_buffer_result[wk_idx++] = coller_pix[0];
00219             user_frame_buffer_result[wk_idx++] = coller_pix[1];
00220         }
00221     }
00222 }
00223 
00224 static void DrawString(const char * str, uint32_t const colour) {
00225     ascii_font.Erase(0x00000090, str_draw_x, str_draw_y,
00226                      (AsciiFont::CHAR_PIX_WIDTH * strlen(str) + 2),
00227                      (AsciiFont::CHAR_PIX_HEIGHT + 2));
00228     ascii_font.DrawStr(str, str_draw_x + 1, str_draw_y + 1, colour, 1);
00229     str_draw_y += AsciiFont::CHAR_PIX_HEIGHT + 1;
00230 #if(1) //mbed client
00231     strcat(send_cloud_buf, str);
00232     strcat(send_cloud_buf, ",");
00233 #endif
00234 }
00235 
00236 static void button_fall(void) {
00237     if (imageNo_setting == HVC_EXECUTE_IMAGE_NONE) {
00238         imageNo_setting = HVC_EXECUTE_IMAGE_QVGA_HALF;
00239     } else if (imageNo_setting == HVC_EXECUTE_IMAGE_QVGA_HALF) {
00240         imageNo_setting = HVC_EXECUTE_IMAGE_QVGA;
00241     } else {
00242         imageNo_setting = HVC_EXECUTE_IMAGE_NONE;
00243     }
00244 }
00245 
00246 void init_recognition_layers(DisplayBase * p_display) {
00247     DisplayBase::rect_t rect;
00248 
00249     /* The layer by which the image is drawn */
00250     rect.vs = 0;
00251     rect.vw = DISP_PIXEL_HEIGHT;
00252     rect.hs = 0;
00253     rect.hw = DISP_PIXEL_WIDTH;
00254     p_display->Graphics_Read_Setting(
00255         DisplayBase::GRAPHICS_LAYER_0,
00256         (void *)user_frame_buffer0,
00257         FRAME_BUFFER_STRIDE,
00258         DisplayBase::GRAPHICS_FORMAT_YCBCR422,
00259         DisplayBase::WR_RD_WRSWA_32_16BIT,
00260         &rect
00261     );
00262     p_display->Graphics_Start(DisplayBase::GRAPHICS_LAYER_0);
00263 
00264     /* The layer by which the image recognition is drawn */
00265     rect.vs = 0;
00266     rect.vw = LCD_PIXEL_HEIGHT;
00267     rect.hs = 0;
00268     rect.hw = DISP_PIXEL_WIDTH;
00269     p_display->Graphics_Read_Setting(
00270         DisplayBase::GRAPHICS_LAYER_1,
00271         (void *)user_frame_buffer_result,
00272         RESULT_BUFFER_STRIDE,
00273         DisplayBase::GRAPHICS_FORMAT_ARGB4444,
00274         DisplayBase::WR_RD_WRSWA_32_16BIT,
00275         &rect
00276     );
00277     p_display->Graphics_Start(DisplayBase::GRAPHICS_LAYER_1);
00278 }
00279 
00280 void recognition_task(DisplayBase * p_display) {
00281     INT32 ret = 0;
00282     UINT8 status;
00283     HVC_VERSION version;
00284     HVC_RESULT *pHVCResult = NULL;
00285     HVC_IMAGE *pImage = NULL;
00286     INT32 execFlag;
00287     INT32 imageNo;
00288     INT32 userID;
00289     INT32 next_userID;
00290     INT32 dataID;
00291     const char *pExStr[] = {"?", "Neutral", "Happiness", "Surprise", "Anger", "Sadness"};
00292     uint32_t i;
00293     char Str_disp[32];
00294     Timer resp_time;
00295 
00296     /* Register the button */
00297     button.fall(&button_fall);
00298 
00299     /* Initializing Recognition layers */
00300     EraseImage();
00301     memset(user_frame_buffer_result, 0, sizeof(user_frame_buffer_result));
00302     init_recognition_layers(p_display);
00303 
00304     /* Result Structure Allocation */
00305     pHVCResult = (HVC_RESULT *)malloc(sizeof(HVC_RESULT));
00306     if (pHVCResult == NULL) {
00307         printf("Memory Allocation Error : %08x\n", sizeof(HVC_RESULT));
00308         mbed_die();
00309     }
00310 
00311     /* Image Structure allocation */
00312     pImage = (HVC_IMAGE *)malloc(sizeof(HVC_IMAGE));
00313     if (pImage == NULL) {
00314         printf("Memory Allocation Error : %08x\n", sizeof(HVC_RESULT));
00315         mbed_die();
00316     }
00317 
00318     while (1) {
00319         /* try to connect a serial device */
00320         while (!serial.connect()) {
00321             Thread::wait(500);
00322         }
00323         serial.baud(921600);
00324         setting_req = true;
00325 
00326         do {
00327             /* Initializing variables */
00328             next_userID = 0;
00329             dataID = 0;
00330 
00331             /* Get Model and Version */
00332             ret = HVC_GetVersion(UART_SETTING_TIMEOUT, &version, &status);
00333             if ((ret != 0) || (status != 0)) {
00334                 break;
00335             }
00336 
00337             while (1) {
00338                 if (!serial.connected()) {
00339                     break;
00340                 }
00341 #if(1) //mbed client
00342                 memset(send_cloud_buf, 0, sizeof(send_cloud_buf));
00343 #endif
00344 
00345                 /* Execute Setting */
00346                 if (setting_req) {
00347                     setting_req = false;
00348                     /* Set Camera Angle */
00349                     ret = HVC_SetCameraAngle(UART_SETTING_TIMEOUT, SENSOR_ROLL_ANGLE_DEFAULT, &status);
00350                     if ((ret != 0) || (status != 0)) {
00351                         break;
00352                     }
00353                     /* Set Threshold Values */
00354                     ret = HVC_SetThreshold(UART_SETTING_TIMEOUT, &setting.threshold, &status);
00355                     if ((ret != 0) || (status != 0)) {
00356                         break;
00357                     }
00358                     ret = HVC_GetThreshold(UART_SETTING_TIMEOUT, &setting.threshold, &status);
00359                     if ((ret != 0) || (status != 0)) {
00360                         break;
00361                     }
00362                     /* Set Detection Size */
00363                     ret = HVC_SetSizeRange(UART_SETTING_TIMEOUT, &setting.sizeRange, &status);
00364                     if ((ret != 0) || (status != 0)) {
00365                         break;
00366                     }
00367                     ret = HVC_GetSizeRange(UART_SETTING_TIMEOUT, &setting.sizeRange, &status);
00368                     if ((ret != 0) || (status != 0)) {
00369                         break;
00370                     }
00371                     /* Set Face Angle */
00372                     ret = HVC_SetFaceDetectionAngle(UART_SETTING_TIMEOUT, setting.pose, setting.angle, &status);
00373                     if ((ret != 0) || (status != 0)) {
00374                         break;
00375                     }
00376                     ret = HVC_GetFaceDetectionAngle(UART_SETTING_TIMEOUT, &setting.pose, &setting.angle, &status);
00377                     if ((ret != 0) || (status != 0)) {
00378                         break;
00379                     }
00380                 }
00381 
00382                 /* Execute Registration */
00383                 if (registrationr_req) {
00384                     int wk_width;
00385 
00386                     if ((pHVCResult->fdResult.num == 1) && (pHVCResult->fdResult.fcResult[0].recognitionResult.uid >= 0)) {
00387                         userID = pHVCResult->fdResult.fcResult[0].recognitionResult.uid;
00388                     } else {
00389                         userID = next_userID;
00390                     }
00391                     ret = HVC_Registration(UART_REGIST_EXECUTE_TIMEOUT, userID, dataID, pImage, &status);
00392                     if ((ret == 0) && (status == 0)) {
00393                         if (userID == next_userID) {
00394                             next_userID++;
00395                             if (next_userID >= USER_ID_NUM_MAX) {
00396                                 next_userID = 0;
00397                             }
00398                         }
00399                         memset(user_frame_buffer_result, 0, sizeof(user_frame_buffer_result));
00400                         DrawImage(128, 88, pImage->width, pImage->height, pImage->image, 1);
00401                         memset(Str_disp, 0, sizeof(Str_disp));
00402                         sprintf(Str_disp, "USER%03d", userID + 1);
00403                         wk_width = (AsciiFont::CHAR_PIX_WIDTH * strlen(Str_disp)) + 2;
00404                         ascii_font.Erase(0x00000090, (DISP_PIXEL_WIDTH - wk_width) / 2, 153, wk_width, (AsciiFont::CHAR_PIX_HEIGHT + 2));
00405                         ascii_font.DrawStr(Str_disp, (DISP_PIXEL_WIDTH - wk_width) / 2 + 1, 154, 0x0000ffff, 1);
00406                         Thread::wait(1200);
00407                     } else {
00408                         if (status == 0x02) {
00409                             wk_width = (AsciiFont::CHAR_PIX_WIDTH * (sizeof(ERROR_02) - 1)) + 4;
00410                             ascii_font.Erase(0x00000090, (DISP_PIXEL_WIDTH - wk_width) / 2, 120, wk_width, (AsciiFont::CHAR_PIX_HEIGHT + 3));
00411                             ascii_font.DrawStr(ERROR_02, (DISP_PIXEL_WIDTH - wk_width) / 2 + 2, 121, 0x0000ffff, 1);
00412                             Thread::wait(1500);
00413                         }
00414                     }
00415                     registrationr_req = false;
00416                 }
00417 
00418                 /* Execute Detection */
00419                 execFlag = setting.execFlag;
00420                 if ((execFlag & HVC_ACTIV_FACE_DETECTION) == 0) {
00421                     execFlag &= ~(HVC_ACTIV_AGE_ESTIMATION | HVC_ACTIV_GENDER_ESTIMATION | HVC_ACTIV_EXPRESSION_ESTIMATION);
00422                 }
00423                 imageNo = imageNo_setting;
00424                 resp_time.reset();
00425                 resp_time.start();
00426                 ret = HVC_ExecuteEx(UART_EXECUTE_TIMEOUT, execFlag, imageNo, pHVCResult, &status);
00427                 resp_time.stop();
00428                 if ((ret == 0) && (status == 0)) {
00429                     if (imageNo == HVC_EXECUTE_IMAGE_QVGA_HALF) {
00430                         DrawImage(0, 0, pHVCResult->image.width, pHVCResult->image.height, pHVCResult->image.image, 2);
00431                     } else if (imageNo == HVC_EXECUTE_IMAGE_QVGA) {
00432                         DrawImage(0, 0, pHVCResult->image.width, pHVCResult->image.height, pHVCResult->image.image, 1);
00433                     } else {
00434                         EraseImage();
00435                     }
00436                     memset(user_frame_buffer_result, 0, sizeof(user_frame_buffer_result));
00437                     if (pHVCResult->executedFunc & HVC_ACTIV_BODY_DETECTION) {
00438                         /* Body Detection result */
00439                         for (i = 0; i < pHVCResult->bdResult.num; i++) {
00440                             DrawSquare(pHVCResult->bdResult.bdResult[i].posX, 
00441                                        pHVCResult->bdResult.bdResult[i].posY,
00442                                        pHVCResult->bdResult.bdResult[i].size,
00443                                        0x000000ff);
00444                         }
00445                     }
00446 
00447                     /* Face Detection result */
00448                     if (pHVCResult->executedFunc &
00449                             (HVC_ACTIV_FACE_DETECTION | HVC_ACTIV_FACE_DIRECTION |
00450                              HVC_ACTIV_AGE_ESTIMATION | HVC_ACTIV_GENDER_ESTIMATION |
00451                              HVC_ACTIV_GAZE_ESTIMATION | HVC_ACTIV_BLINK_ESTIMATION |
00452                              HVC_ACTIV_EXPRESSION_ESTIMATION | HVC_ACTIV_FACE_RECOGNITION)){
00453                         for (i = 0; i < pHVCResult->fdResult.num; i++) {
00454 #if(1) //mbed client
00455                             strcat(send_cloud_buf, "{");
00456 #endif
00457                             if (pHVCResult->executedFunc & HVC_ACTIV_FACE_DETECTION) {
00458                                 uint32_t detection_colour = 0x0000f0f0; /* green */
00459 
00460                                 if (pHVCResult->executedFunc & HVC_ACTIV_FACE_RECOGNITION) {
00461                                     if (pHVCResult->fdResult.fcResult[i].recognitionResult.uid >= 0) {
00462                                         detection_colour = 0x0000fff4; /* blue */
00463                                     }
00464                                 }
00465                                 /* Detection */
00466                                 DrawSquare(pHVCResult->fdResult.fcResult[i].dtResult.posX,
00467                                            pHVCResult->fdResult.fcResult[i].dtResult.posY,
00468                                            pHVCResult->fdResult.fcResult[i].dtResult.size,
00469                                            detection_colour);
00470                             }
00471                             if (pHVCResult->executedFunc & HVC_ACTIV_FACE_RECOGNITION) {
00472                                 /* Recognition */
00473                                 if (-128 == pHVCResult->fdResult.fcResult[i].recognitionResult.uid) {
00474                                     DrawString("Not possible", 0x0000f0ff);
00475                                 } else if (pHVCResult->fdResult.fcResult[i].recognitionResult.uid < 0) {
00476                                     DrawString("Not registered", 0x0000f0ff);
00477                                 } else {
00478                                     memset(Str_disp, 0, sizeof(Str_disp));
00479                                     sprintf(Str_disp, "USER%03d", pHVCResult->fdResult.fcResult[i].recognitionResult.uid + 1);
00480                                     DrawString(Str_disp, 0x0000f0ff);
00481                                 }
00482                             }
00483                             if (pHVCResult->executedFunc & HVC_ACTIV_AGE_ESTIMATION) {
00484                                 /* Age */
00485                                 if (-128 != pHVCResult->fdResult.fcResult[i].ageResult.age) {
00486                                     memset(Str_disp, 0, sizeof(Str_disp));
00487                                     sprintf(Str_disp, "Age:%d", pHVCResult->fdResult.fcResult[i].ageResult.age);
00488                                     DrawString(Str_disp, 0x0000f0ff);
00489                                 }
00490                             }
00491                             if (pHVCResult->executedFunc & HVC_ACTIV_GENDER_ESTIMATION) {
00492                                 /* Gender */
00493                                 if (-128 != pHVCResult->fdResult.fcResult[i].genderResult.gender) {
00494                                     if (1 == pHVCResult->fdResult.fcResult[i].genderResult.gender) {
00495                                         DrawString("Male", 0x0000fff4);
00496                                     } else {
00497                                         DrawString("Female", 0x00006dff);
00498                                     }
00499                                 }
00500                             }
00501                             if (pHVCResult->executedFunc & HVC_ACTIV_EXPRESSION_ESTIMATION) {
00502                                 /* Expression */
00503                                 if (-128 != pHVCResult->fdResult.fcResult[i].expressionResult.score[0]) {
00504                                     uint32_t colour;
00505 
00506                                     if (pHVCResult->fdResult.fcResult[i].expressionResult.topExpression > EX_SADNESS) {
00507                                         pHVCResult->fdResult.fcResult[i].expressionResult.topExpression = 0;
00508                                     }
00509                                     switch (pHVCResult->fdResult.fcResult[i].expressionResult.topExpression) {
00510                                         case 1:  colour = 0x0000ffff; break;  /* white */
00511                                         case 2:  colour = 0x0000f0ff; break;  /* yellow */
00512                                         case 3:  colour = 0x000060ff; break;  /* orange */
00513                                         case 4:  colour = 0x00000fff; break;  /* purple */
00514                                         case 5:  colour = 0x0000fff4; break;  /* blue */
00515                                         default: colour = 0x0000ffff; break;  /* white */
00516                                     }
00517                                     DrawString(pExStr[pHVCResult->fdResult.fcResult[i].expressionResult.topExpression], colour);
00518                                 }
00519                             }
00520 #if(1) //mbed client
00521                             send_cloud_buf[strlen(send_cloud_buf) - 1] = '\0';
00522                             strcat(send_cloud_buf, "}");
00523 #endif
00524                         }
00525                     }
00526                 }
00527                 /* Response time */
00528                 memset(Str_disp, 0, sizeof(Str_disp));
00529                 sprintf(Str_disp, "Response time:%dms", resp_time.read_ms());
00530                 ascii_font.Erase(0, 0, 0, 0, 0);
00531                 ascii_font.DrawStr(Str_disp, 0, LCD_PIXEL_HEIGHT - AsciiFont::CHAR_PIX_HEIGHT, 0x0000ffff, 1);
00532 #if(1) //mbed client
00533                 if (strlen(send_cloud_buf) > 0) {
00534                     HVCSendData(send_cloud_buf, strlen(send_cloud_buf));
00535                 }
00536                 Thread::wait(10);
00537 #endif
00538             }
00539         } while(0);
00540 
00541         EraseImage();
00542         memset(user_frame_buffer_result, 0, sizeof(user_frame_buffer_result));
00543     }
00544 }