Sample to operate omron HVC-P2 on GR-PEACH.

Dependencies:   AsciiFont

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers STBValidValue.c Source File

STBValidValue.c

00001 /*---------------------------------------------------------------------------*/
00002 /* Copyright(C)  2017  OMRON Corporation                                     */
00003 /*                                                                           */
00004 /* Licensed under the Apache License, Version 2.0 (the "License");           */
00005 /* you may not use this file except in compliance with the License.          */
00006 /* You may obtain a copy of the License at                                   */
00007 /*                                                                           */
00008 /*     http://www.apache.org/licenses/LICENSE-2.0                            */
00009 /*                                                                           */
00010 /* Unless required by applicable law or agreed to in writing, software       */
00011 /* distributed under the License is distributed on an "AS IS" BASIS,         */
00012 /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  */
00013 /* See the License for the specific language governing permissions and       */
00014 /* limitations under the License.                                            */
00015 /*---------------------------------------------------------------------------*/
00016 
00017 #include "STBValidValue.h"
00018 
00019 /*Value range check*/
00020 #define IS_OUT_RANGE( val , min , max ) ( ( (val) < (min) ) || ( (max) < (val) ) )
00021 #define IS_OUT_VALUE( val , min , max , accept ) ( IS_OUT_RANGE( val , min , max ) && ( (val) != (accept) )  )
00022 #define IS_OUT_FR_UID( val , min , max , acceptA , acceptB , acceptC  ) ( IS_OUT_RANGE( val , min , max ) && ( (val) != (acceptA) ) && ( (val) != (acceptB) ) && ( (val) != (acceptC) ) )
00023 #define IS_OUT_FR_SCORE( val , min , max , acceptA , acceptB ) ( IS_OUT_RANGE( val , min , max ) && ( (val) != (acceptA) ) && ( (val) != (acceptB) )  )
00024 
00025 /*------------------------------------------------------------------------------------------------------------------*/
00026 /* STB_IsValidValue                                                                                            */
00027 /*------------------------------------------------------------------------------------------------------------------*/
00028 STB_INT32 STB_IsValidValue(const STB_FRAME_RESULT *input, STBExecFlg *execFlg)
00029 {
00030     STB_INT32 i ,j;
00031 
00032 
00033 
00034     if( execFlg->bodyTr == STB_TRUE )
00035     {
00036         if( IS_OUT_RANGE( input->bodys.nCount , STB_BODY_CNT_MIN , STB_BODY_CNT_MAX )    ){ return STB_FALSE;}
00037         for( i = 0 ; i < input->bodys.nCount ; i++)
00038         {
00039             if( IS_OUT_RANGE( input->bodys.body[i].center.nX    , STB_BODY_XY_MIN    , STB_BODY_XY_MAX    )    ){ return STB_FALSE;}
00040             if( IS_OUT_RANGE( input->bodys.body[i].center.nY    , STB_BODY_XY_MIN    , STB_BODY_XY_MAX    )    ){ return STB_FALSE;}
00041             if( IS_OUT_RANGE( input->bodys.body[i].nSize        , STB_BODY_SIZE_MIN , STB_BODY_SIZE_MAX )    ){ return STB_FALSE;}
00042             if( IS_OUT_RANGE( input->bodys.body[i].nConfidence    , STB_BODY_CONF_MIN , STB_BODY_CONF_MAX )    ){ return STB_FALSE;}
00043         }
00044         
00045     }
00046 
00047     if( execFlg->faceTr == STB_TRUE )
00048     {
00049         if( IS_OUT_RANGE( input->faces.nCount , STB_FACE_CNT_MIN , STB_FACE_CNT_MAX )    ){ return STB_FALSE;}
00050         for( i = 0 ; i < input->faces.nCount ; i++)
00051         {
00052             if( IS_OUT_RANGE( input->faces.face[i].center.nX    , STB_FACE_XY_MIN    , STB_FACE_XY_MAX    )    ){ return STB_FALSE;}
00053             if( IS_OUT_RANGE( input->faces.face[i].center.nY    , STB_FACE_XY_MIN    , STB_FACE_XY_MAX    )    ){ return STB_FALSE;}
00054             if( IS_OUT_RANGE( input->faces.face[i].nSize        , STB_FACE_SIZE_MIN , STB_FACE_SIZE_MAX )    ){ return STB_FALSE;}
00055             if( IS_OUT_RANGE( input->faces.face[i].nConfidence    , STB_FACE_CONF_MIN , STB_FACE_CONF_MAX )    ){ return STB_FALSE;}
00056         }
00057     }
00058 
00059     if(        execFlg->gen    == STB_TRUE     
00060         ||    execFlg->age    == STB_TRUE 
00061         ||    execFlg->fr        == STB_TRUE 
00062         ||    execFlg->exp    == STB_TRUE     
00063         ||    execFlg->dir    == STB_TRUE     
00064         ||    execFlg->gaz    == STB_TRUE 
00065         ||    execFlg->bli    == STB_TRUE 
00066         )
00067     {
00068         for( i = 0 ; i < input->faces.nCount ; i++)
00069         {
00070             if( IS_OUT_RANGE( input->faces.face[i].direction.nLR            , STB_FACE_DIR_LR_MIN    , STB_FACE_DIR_LR_MAX    )    ){ return STB_FALSE;}
00071             if( IS_OUT_RANGE( input->faces.face[i].direction.nUD            , STB_FACE_DIR_UD_MIN    , STB_FACE_DIR_UD_MAX    )    ){ return STB_FALSE;}
00072             if( IS_OUT_RANGE( input->faces.face[i].direction.nRoll            , STB_FACE_DIR_ROLL_MIN    , STB_FACE_DIR_ROLL_MAX )    ){ return STB_FALSE;}
00073             if( IS_OUT_RANGE( input->faces.face[i].direction.nConfidence    , STB_FACE_DIR_CONF_MIN    , STB_FACE_DIR_CONF_MAX )    ){ return STB_FALSE;}
00074         }
00075     }
00076 
00077 
00078     if(    execFlg->age    == STB_TRUE )
00079     {
00080         for( i = 0 ; i < input->faces.nCount ; i++)
00081         {
00082             if( IS_OUT_VALUE( input->faces.face[i].age.nAge            , STB_FACE_AGE_VAL_MIN    , STB_FACE_AGE_VAL_MAX    ,STB_ERR_PE_CANNOT )    ){ return STB_FALSE;}
00083             if( IS_OUT_VALUE( input->faces.face[i].age.nConfidence    , STB_FACE_AGE_CONF_MIN    , STB_FACE_AGE_CONF_MAX    ,STB_ERR_PE_CANNOT )    ){ return STB_FALSE;}
00084         }
00085     }
00086 
00087     if(    execFlg->gen    == STB_TRUE )
00088     {
00089         for( i = 0 ; i < input->faces.nCount ; i++)
00090         {
00091             if( IS_OUT_VALUE( input->faces.face[i].gender.nGender        , STB_FACE_GEN_VAL_MIN    , STB_FACE_GEN_VAL_MAX    ,STB_ERR_PE_CANNOT )    ){ return STB_FALSE;}
00092             if( IS_OUT_VALUE( input->faces.face[i].gender.nConfidence    , STB_FACE_GEN_CONF_MIN    , STB_FACE_GEN_CONF_MAX    ,STB_ERR_PE_CANNOT )    ){ return STB_FALSE;}
00093         }
00094     }
00095 
00096     if(    execFlg->gaz    == STB_TRUE )
00097     {
00098         for( i = 0 ; i < input->faces.nCount ; i++)
00099         {
00100             if( IS_OUT_VALUE( input->faces.face[i].gaze.nLR    , STB_FACE_GAZE_LR_MIN    , STB_FACE_GAZE_LR_MAX    ,STB_ERR_PE_CANNOT )    ){ return STB_FALSE;}
00101             if( IS_OUT_VALUE( input->faces.face[i].gaze.nUD    , STB_FACE_GAZE_UD_MIN    , STB_FACE_GAZE_UD_MAX    ,STB_ERR_PE_CANNOT )    ){ return STB_FALSE;}
00102         }
00103     }
00104 
00105     if(    execFlg->bli    == STB_TRUE )
00106     {
00107         for( i = 0 ; i < input->faces.nCount ; i++)
00108         {
00109             if( IS_OUT_VALUE( input->faces.face[i].blink.nLeftEye    , STB_FACE_BLI_L_MIN    , STB_FACE_BLI_L_MAX    ,STB_ERR_PE_CANNOT)    ){ return STB_FALSE;}
00110             if( IS_OUT_VALUE( input->faces.face[i].blink.nRightEye    , STB_FACE_BLI_R_MIN    , STB_FACE_BLI_R_MAX    ,STB_ERR_PE_CANNOT)    ){ return STB_FALSE;}
00111         }
00112     }
00113 
00114     if(    execFlg->exp    == STB_TRUE )
00115     {
00116         for( i = 0 ; i < input->faces.nCount ; i++)
00117         {
00118             if( IS_OUT_VALUE( input->faces.face[i].expression.nDegree    , STB_FACE_EXP_DEG_MIN    , STB_FACE_EXP_DEG_MAX    ,STB_ERR_PE_CANNOT)    ){ return STB_FALSE;}
00119             for( j = 0 ; j < STB_EX_MAX ; j++)
00120             {
00121                 if( IS_OUT_VALUE( input->faces.face[i].expression.anScore[j]    ,STB_FACE_EXP_SCORE_MIN    , STB_FACE_EXP_SCORE_MAX    ,STB_ERR_PE_CANNOT)    ){ return STB_FALSE;}
00122             }
00123             
00124         }
00125     }
00126 
00127     if(    execFlg->fr    == STB_TRUE )
00128     {
00129         for( i = 0 ; i < input->faces.nCount ; i++)
00130         {
00131             if( IS_OUT_FR_UID( input->faces.face[i].recognition.nUID    , STB_FACE_FR_UID_MIN    , STB_FACE_FR_UID_MAX    ,STB_ERR_FR_CANNOT ,STB_ERR_FR_NOID ,STB_ERR_FR_NOALBUM ) ){ return STB_FALSE;}
00132             if( IS_OUT_FR_SCORE( input->faces.face[i].recognition.nScore    , STB_FACE_FR_SCORE_MIN    , STB_FACE_FR_SCORE_MAX    ,STB_ERR_FR_CANNOT ,STB_ERR_FR_NOALBUM)    ){ return STB_FALSE;}
00133         }
00134     }
00135 
00136 
00137     return STB_TRUE;
00138 }