/**
* Contrast Characterization Unit Test Cases.
*/
TInt32 test_metric_contrast_characterization(TUint8* aDirPath)
{
TAlgoError ret = EErrorNone;
TAlgoMetricParams aMetricParams;
TUint8 dir[128];
TUint8 dir1[128];
aMetricParams.iErrorTolerance.iErrorToleranceR = 0;
aMetricParams.iErrorTolerance.iErrorToleranceG = 0;
aMetricParams.iErrorTolerance.iErrorToleranceB = 0;
aMetricParams.iType = ETypeContrast;
aMetricParams.iTestCoordinates.iStartIndexX = 0;
aMetricParams.iTestCoordinates.iStartIndexY = 0;
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
ALGO_Log_0("*************CONTRAST METRIC TEST 1************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Contrast\\CONTRAST_IM1_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Contrast\\CONTRAST_IM1_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************CONTRAST METRIC TEST 2************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Contrast\\CONTRAST_IM2_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Contrast\\CONTRAST_IM2_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************CONTRAST METRIC TEST 3************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Contrast\\CONTRAST_IM3_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Contrast\\CONTRAST_IM3_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************CONTRAST METRIC TEST 4************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Contrast\\CONTRAST_IM4_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Contrast\\CONTRAST_IM4_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************CONTRAST METRIC TEST 5************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Contrast\\CONTRAST_IM5_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Contrast\\CONTRAST_IM5_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
return 0;
}
/**
* Validation Metric for the Black and White Effect.
*
* @param aImageEffectDisable [TAlgoImage] The image with Effect Disable.
* @param aImageEffectEnable [TAlgoImage] The image with Effect Enable.
* @param aMetricParams [TAlgoMetricParams]The metric parameters to be applied.
*
* @return [TAlgoError] EErrorNone if the validation is passed.
*/
TAlgoError ValidationMetricBlackAndWhiteEffect( const TAlgoImage* aImageEffectDisable,
const TAlgoImage* aImageEffectEnable,
const TAlgoMetricParams* aMetricParams )
{
TAlgoError errorCode = EErrorNotValidated;
TReal64 tolerance = 0;
TReal64 R_Avg_Im1 = 0;
TReal64 G_Avg_Im1 = 0;
TReal64 B_Avg_Im1 = 0;
TReal64 R_Avg_Im2 = 0;
TReal64 G_Avg_Im2 = 0;
TReal64 B_Avg_Im2 = 0;
ALGO_Log_1("entering %s\n", __FUNCTION__);
ALGO_Log_3("ToleranceR = %f, ToleranceG = %f, ToleranceB = %f\n", aMetricParams->iErrorTolerance.iErrorToleranceR, aMetricParams->iErrorTolerance.iErrorToleranceG, aMetricParams->iErrorTolerance.iErrorToleranceB);
Channel_Average( aImageEffectDisable, &(aMetricParams->iTestCoordinates), &R_Avg_Im1, &G_Avg_Im1, &B_Avg_Im1 );
Channel_Average( aImageEffectEnable, &(aMetricParams->iTestCoordinates), &R_Avg_Im2, &G_Avg_Im2, &B_Avg_Im2 );
//ALGO_Log_1("R_Average %f\n",R_Avg_Im1);
//ALGO_Log_1("G_Average %f\n",G_Avg_Im1);
//ALGO_Log_1("B_Average %f\n",B_Avg_Im1);
tolerance = BLACKANDWHITE_THRESHOLD + ((aMetricParams->iErrorTolerance.iErrorToleranceR * BLACKANDWHITE_THRESHOLD)/100);
if(
(ABS(R_Avg_Im2 - G_Avg_Im2) <= tolerance)&&
(ABS(G_Avg_Im2 - B_Avg_Im2) <= tolerance) &&
(ABS(B_Avg_Im2 - R_Avg_Im2) <= tolerance)
)
//if(R_Avg_Im2 == G_Avg_Im2 == B_Avg_Im2)
{
ALGO_Log_1("R_Average2 %f\n",R_Avg_Im2);
ALGO_Log_1("G_Average2 %f\n",G_Avg_Im2);
ALGO_Log_1("B_Average2 %f\n",B_Avg_Im2);
ALGO_Log_2("ABS(R_Avg_Im2 - G_Avg_Im2) %f, tolerance %f\n", ABS(R_Avg_Im2 - G_Avg_Im2), tolerance);
ALGO_Log_2("ABS(G_Avg_Im2 - B_Avg_Im2) %f, tolerance %f\n", ABS(G_Avg_Im2 - B_Avg_Im2), tolerance);
ALGO_Log_2("ABS(B_Avg_Im2 - R_Avg_Im2) %f, tolerance %f\n", ABS(B_Avg_Im2 - R_Avg_Im2), tolerance);
ALGO_Log_0("Metric BlackAndWhiteEffect : EErrorNone\n");
errorCode = EErrorNone;
}
else
{
ALGO_Log_1("R_Average2 %f\n",R_Avg_Im2);
ALGO_Log_1("G_Average2 %f\n",G_Avg_Im2);
ALGO_Log_1("B_Average2 %f\n",B_Avg_Im2);
ALGO_Log_2("ABS(R_Avg_Im2 - G_Avg_Im2) %f, tolerance %f\n", ABS(R_Avg_Im2 - G_Avg_Im2), tolerance);
ALGO_Log_2("ABS(G_Avg_Im2 - B_Avg_Im2) %f, tolerance %f\n", ABS(G_Avg_Im2 - B_Avg_Im2), tolerance);
ALGO_Log_2("ABS(B_Avg_Im2 - R_Avg_Im2) %f, tolerance %f\n", ABS(B_Avg_Im2 - R_Avg_Im2), tolerance);
ALGO_Log_0("Metric BlackAndWhiteEffect : EErrorNotValidated\n");
errorCode = EErrorNotValidated;
}
return errorCode;
}
/**
* Gamma Characterization Unit Test Cases.
*/
TInt32 test_metric_gamma_characterization(TUint8* aDirPath)
{
TAlgoError ret = EErrorNone;
TAlgoMetricParams aMetricParams;
TUint8 dir[128];
TUint8 dir1[128];
TUint32 memDisable = 0;
TUint32 memEnable = 0;
//TAlgoImageParams aImageParams;
TUint64 size = 0;
aMetricParams.iErrorTolerance.iErrorToleranceR = 0;
aMetricParams.iErrorTolerance.iErrorToleranceG = 0;
aMetricParams.iErrorTolerance.iErrorToleranceB = 0;
aMetricParams.iType = ETypeGamma;
aMetricParams.iTestCoordinates.iStartIndexX = 0;
aMetricParams.iTestCoordinates.iStartIndexY = 0;
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
/*
ALGO_Log_0("*************GAMMA METRIC TEST 1************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Gamma\\GAMMA_IM1_Disable.gam");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Gamma\\GAMMA_IM1_Enable.gam");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************GAMMA METRIC TEST 2************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Gamma\\GAMMA_IM2_Disable.yuv");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Gamma\\GAMMA_IM2_Enable.yuv");
aImageParams.iImageFormat = EImageFormatYUV422Interleaved;
aImageParams.iImageHeight = 480;
aImageParams.iImageWidth = 640;
aImageParams.iImageHeaderLength = 0;
ret = ValidationMetricInterfaceWithFiles(&aImageParams, &aImageParams, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
*/
ALGO_Log_0("*************GAMMA METRIC TEST 3************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Gamma\\GAMMA_IM3_Disable.gam");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Gamma\\GAMMA_IM3_Enable.gam");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
return 0;
}
// Histogram Draw Function
TAlgoError DrawHistogram( TUint32* aHistogram, TUint32 aMaxValue )
{
TUint32 loop1 =0;
TUint32 loop2 = 0;
ALGO_Log_0("Array Element Value in Element Histogram \n");
ALGO_Log_0("------------- ---------------- --------- \n");
for ( loop1 =0; loop1 < aMaxValue; loop1 = loop1+8)
{
ALGO_Log_1("%7d", loop1);
ALGO_Log_1("%19d ", aHistogram[loop1]);
for (loop2 = 0; loop2 < aHistogram[loop1]; loop2 = loop2+8){
ALGO_Log_0("*");
}
ALGO_Log_0("\n");
}
ALGO_Log_0("\n\n");
return EErrorNone;
}
/**
* Spatial Similar Unit Test Cases.
*/
TInt32 test_metric_spatialsimilar(char *aFileNameImageEffectDisable, char *aFileNameImageEffectEnable)
{
TAlgoError ret = EErrorNone;
TAlgoMetricParams aMetricParams;
ALGO_Log_0("************* SPATIAL SIMILAR METRIC TEST ************ \n");
aMetricParams.iErrorTolerance.iErrorToleranceR = 0;
aMetricParams.iErrorTolerance.iErrorToleranceG = 0;
aMetricParams.iErrorTolerance.iErrorToleranceB = 0;
aMetricParams.iType = ETypeSpatialSimilar;
aMetricParams.iMetricRange.iRangeR = 0;
aMetricParams.iMetricRange.iRangeG = 0;
aMetricParams.iMetricRange.iRangeB = 0;
aMetricParams.iParams = (TAny*)NULL;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, aFileNameImageEffectDisable, aFileNameImageEffectEnable, &aMetricParams);
Metrcis_Print_Result(ret);
return 0;
}
/**
* Validation Metric for the ExposurePreset.
*
* @param aImageEffectDisable [TAlgoImage] The image with Effect Disable.
* @param aImageEffectEnable [TAlgoImage] The image with Effect Enable.
* @param aMetricParams [TAlgoMetricParams]The metric parameters to be applied.
*
* @return [TAlgoError] EErrorNone if the validation is passed.
*/
TAlgoError ValidationMetricExposurePreset( const TAlgoImage* aImageEffectDisable,
const TAlgoImage* aImageEffectEnable,
const TAlgoMetricParams* aMetricParams )
{
TAlgoParamExposurePreset *paramExposurePreset = (TAlgoParamExposurePreset*)aMetricParams->iParams;
TAlgoError error = EErrorNotValidated;
TUint32 i = 0;
TUint32 j = 0;
TUint32 temp = 0;
TUint32 medianArrayDisable[256] = {0};
TUint32 medianArrayEnable[256] = {0};
TUint32 medianDisable = 0;
TUint32 medianEnable = 0;
TUint32 index = 0;
TReal64 Avg_Disable = 0;
TReal64 Avg_Enable = 0;
TReal64 diff=0, diffPercentage=0;
TUint32 startingOffset = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth
+ aMetricParams->iTestCoordinates.iStartIndexX;
TUint32 offset = (aImageEffectDisable->iImageParams.iImageWidth - aMetricParams->iTestCoordinates.iPixelsToGrabX);
ALGO_Log_1("entering %s\n", __FUNCTION__);
ALGO_Log_3("ToleranceR = %f, ToleranceG = %f, ToleranceB = %f\n", aMetricParams->iErrorTolerance.iErrorToleranceR, aMetricParams->iErrorTolerance.iErrorToleranceG, aMetricParams->iErrorTolerance.iErrorToleranceB);
ALGO_Log_3("ExposurePreset Metric : iExpoPreset_1 %d, iExpoPreset_2 %d, iTolerance %d\n\n", paramExposurePreset->iExpoPreset_1, paramExposurePreset->iExpoPreset_2, paramExposurePreset->iTolerance);
//Getting the luma component for both images in the R Channel.
for( index=0; index<(aImageEffectDisable->iImageParams.iImageHeight *
aImageEffectDisable->iImageParams.iImageWidth); index++)
{
aImageEffectDisable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectDisable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectDisable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectDisable->iImageData.iBChannel[index]);
aImageEffectEnable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectEnable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectEnable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectEnable->iImageData.iBChannel[index]);
medianArrayDisable[aImageEffectDisable->iImageData.iRChannel[index]]++;
medianArrayEnable[aImageEffectEnable->iImageData.iRChannel[index]]++;
}
//Calculating the average of luma components of both images.
index = startingOffset;
for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabY; i++ )
{
for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabX; j++)
{
Avg_Disable = Avg_Disable + aImageEffectDisable->iImageData.iRChannel[index];
Avg_Enable = Avg_Enable + aImageEffectEnable->iImageData.iRChannel[index];
index++;
}
index = index + offset;
}
Avg_Disable = Avg_Disable/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY);
Avg_Enable = Avg_Enable/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY);
//Calculating the median
temp = 0;
for( i=0; i<256; i++ )
{
temp = temp + medianArrayDisable[i];
if(temp > (aImageEffectDisable->iImageParams.iImageHeight * aImageEffectDisable->iImageParams.iImageWidth)/2)
{
break;
}
}
medianDisable = i;
temp = 0;
for( i=0; i<256; i++ )
{
temp = temp + medianArrayEnable[i];
if(temp > (aImageEffectEnable->iImageParams.iImageHeight * aImageEffectEnable->iImageParams.iImageWidth)/2)
{
break;
}
}
medianEnable = i;
//Doing median Check
if(((ABS(Avg_Disable - medianDisable)) < 10) && ((ABS(Avg_Enable - medianEnable)) < 10))
{
ALGO_Log_0("Exposure Preset Metric : Median Check PASSED\n");
ALGO_Log_2("Exposure Preset Metric : Average Disable = %.3f, Median Disable = %d\n", Avg_Disable, medianDisable);
ALGO_Log_2("Exposure Preset Metric : Average Enable = %.3f, Median Enable = %d\n\n", Avg_Enable, medianEnable);
}
else
{
ALGO_Log_0("Exposure Preset Metric : Median Check FAILED\n");
ALGO_Log_2("Exposure Preset Metric : Average Disable = %.3f, Median Disable = %d\n", Avg_Disable, medianDisable);
ALGO_Log_2("Exposure Preset Metric : Average Enable = %.3f, Median Enable = %d\n\n", Avg_Enable, medianEnable);
}
diff = ABS(Avg_Disable - Avg_Enable) ;
diffPercentage = (diff / 256)*100;
ALGO_Log_2("Avg_Disable = %.3f, Avg_Enable = %.3f\n", Avg_Disable, Avg_Enable);
ALGO_Log_3("diff = %.3f, diffPercentage = %.3f, tolerance = %d\n", diff, diffPercentage, paramExposurePreset->iTolerance);
if( diffPercentage < paramExposurePreset->iTolerance )
{
error = EErrorNone;
}
else
{
error = EErrorNotValidated;
ALGO_Log_2("diffPercentage = %.1f, iTolerance = %d\n", diffPercentage, paramExposurePreset->iTolerance);
ALGO_Log_1("Error in %s\n", __FUNCTION__);
}
return error;
}
/**
* Color Tone Characterization Unit Test Cases.
*/
TInt32 test_metric_colortone_characterization(TUint8* aDirPath)
{
TAlgoError ret = EErrorNone;
TAlgoMetricParams aMetricParams;
TUint8 dir[128];
TUint8 dir1[128];
TAlgoMatrix matrix;
TUint32 memDisable = 0;
TUint32 memEnable = 0;
//TUint8* bufferEffectDisable;
//TUint8* bufferEffectEnable;
//TAlgoImageParams aImageParams;
//TAny* file;
//TAny* file1;
TUint64 size = 0;
aMetricParams.iErrorTolerance.iErrorToleranceR = 20;
aMetricParams.iErrorTolerance.iErrorToleranceG = 20;
aMetricParams.iErrorTolerance.iErrorToleranceB = 20;
aMetricParams.iType = ETypeColorTone;
aMetricParams.iTestCoordinates.iStartIndexX = 0;
aMetricParams.iTestCoordinates.iStartIndexY = 0;
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
matrix.iMatrix[0][0] = (TReal32)2.5415;
matrix.iMatrix[0][1] = (TReal32)-1.5587;
matrix.iMatrix[0][2] = (TReal32)0.0173;
matrix.iMatrix[1][0] = (TReal32)-0.6080;
matrix.iMatrix[1][1] = (TReal32)2.2818;
matrix.iMatrix[1][2] = (TReal32)-0.6739;
matrix.iMatrix[2][0] = (TReal32)-0.0365;
matrix.iMatrix[2][1] = (TReal32)-0.6038;
matrix.iMatrix[2][2] = (TReal32)1.6403;
aMetricParams.iParams = &matrix;
ALGO_Log_0("*************COLOR TONE METRIC TEST 1************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\ColorTone\\COLORTONE_IM1_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\ColorTone\\COLORTONE_IM1_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************COLOR TONE METRIC TEST 2************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\ColorTone\\COLORTONE_IM2_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\ColorTone\\COLORTONE_IM2_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************COLOR TONE METRIC TEST 3************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\ColorTone\\COLORTONE_IM3_Disable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\ColorTone\\COLORTONE_IM3_Enable.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
Metrcis_Print_Result(ret);
return 0;
}
/**
* centerfieldofview Unit Test Cases.
*/
TInt32 test_metric_centerfieldofview_characterization(TUint8* aDirPath)
{
TAlgoError ret = EErrorNone;
TAlgoMetricParams aMetricParams;
TInt8 *pString = NULL;
TInt8 *pHandle = NULL;
TInt32 nX = 0, nY = 0, nX1 = 0, nY1 = 0;
TUint8 dir[128];
TUint8 dir1[128];
TAlgoParamCenterFieldOfView paramCenterFieldOfView;
char cfow_patern[]="_cfow_";
ALGO_Log_0("*************CENTERFIELDOFVIEW METRIC TEST 1************ \n");
pString = dir;
AlgoStrcpy(pString, aDirPath);
AlgoStrcat(pString, "cfow//frame_1__reso_320_x_240_id_001_format_bmp_cfow_0_0.bmp");
pHandle = strstr(pString, cfow_patern);
if(pHandle)
{
pHandle += strlen(cfow_patern);
sscanf (pHandle,"%d_%d", &nX, &nY);
ALGO_Log_2 ("detected nX %d , nY %d\n", nX, nY);
}
else
{
ALGO_Log_0("cfow not recognazied\n");
}
pString = dir1;
AlgoStrcpy(pString, aDirPath);
AlgoStrcat(pString, "cfow//frame_1__reso_320_x_240_id_002_format_bmp_cfow_16_32.bmp");
pHandle = strstr(pString, cfow_patern);
if(pHandle)
{
pHandle += strlen(cfow_patern);
sscanf (pHandle,"%d_%d", &nX1, &nY1);
ALGO_Log_2 ("detected nX %d , nY %d\n", nX1, nY1);
}
else
{
ALGO_Log_0("cfow not recognazied\n");
}
aMetricParams.iType = ETypeCenterFieldOfView;
aMetricParams.iErrorTolerance.iErrorToleranceR = 5;
aMetricParams.iErrorTolerance.iErrorToleranceG = 0;
aMetricParams.iErrorTolerance.iErrorToleranceB = 0;
aMetricParams.iMetricRange.iRangeR = 0;
aMetricParams.iMetricRange.iRangeG = 0;
aMetricParams.iMetricRange.iRangeB = 0;
aMetricParams.iTestCoordinates.iStartIndexX = 0; // not used
aMetricParams.iTestCoordinates.iStartIndexY = 0; // not used
aMetricParams.iTestCoordinates.iPixelsToGrabX = 0; // size max of common widow is computed by metric
aMetricParams.iTestCoordinates.iPixelsToGrabY = 0; // size max of common widow is computed by metric
paramCenterFieldOfView.iX = nX1 - nX;
paramCenterFieldOfView.iY = nY1 - nY;
paramCenterFieldOfView.iTolerance = 5;
aMetricParams.iParams = ¶mCenterFieldOfView;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************CENTERFIELDOFVIEW METRIC TEST 2************ \n");
pString = dir;
AlgoStrcpy(pString, aDirPath);
AlgoStrcat(pString, "cfow//frame_1__reso_320_x_240_id_001_format_bmp_cfow_0_0.bmp");
pHandle = strstr(pString, cfow_patern);
if(pHandle)
{
pHandle += strlen(cfow_patern);
sscanf (pHandle,"%d_%d", &nX, &nY);
ALGO_Log_2 ("detected nX %d , nY %d\n", nX, nY);
}
else
{
ALGO_Log_0("cfow not recognazied\n");
}
pString = dir1;
AlgoStrcpy(pString, aDirPath);
AlgoStrcat(pString, "cfow//frame_1__reso_320_x_240_id_002_format_bmp_cfow_16_-32.bmp");
pHandle = strstr(pString, cfow_patern);
if(pHandle)
{
pHandle += strlen(cfow_patern);
sscanf (pHandle,"%d_%d", &nX1, &nY1);
ALGO_Log_2 ("detected nX %d , nY %d\n", nX1, nY1);
}
else
{
ALGO_Log_0("cfow not recognazied\n");
}
aMetricParams.iType = ETypeCenterFieldOfView;
aMetricParams.iErrorTolerance.iErrorToleranceR = 5;
aMetricParams.iErrorTolerance.iErrorToleranceG = 0;
aMetricParams.iErrorTolerance.iErrorToleranceB = 0;
aMetricParams.iMetricRange.iRangeR = 0;
aMetricParams.iMetricRange.iRangeG = 0;
aMetricParams.iMetricRange.iRangeB = 0;
aMetricParams.iTestCoordinates.iStartIndexX = 0; // not used
aMetricParams.iTestCoordinates.iStartIndexY = 0; // not used
aMetricParams.iTestCoordinates.iPixelsToGrabX = 0; // size max of common widow is computed by metric
aMetricParams.iTestCoordinates.iPixelsToGrabY = 0; // size max of common widow is computed by metric
paramCenterFieldOfView.iX = nX1 - nX;
paramCenterFieldOfView.iY = nY1 - nY;
paramCenterFieldOfView.iTolerance = 5;
aMetricParams.iParams = ¶mCenterFieldOfView;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
return 0;
}
/**
* Negative Characterization Unit Test Cases.
*/
TInt32 test_metric_negative_characterization(TUint8* aDirPath)
{
TAlgoError ret = EErrorNone;
TAlgoMetricRange metricRange;
TAlgoMetricParams aMetricParams;
TUint8 dir[128];
TUint8 dir1[128];
metricRange.iRangeR = 0;
metricRange.iRangeG = 0;
metricRange.iRangeB = 0;
aMetricParams.iErrorTolerance.iErrorToleranceR = 2;
aMetricParams.iErrorTolerance.iErrorToleranceG = 2;
aMetricParams.iErrorTolerance.iErrorToleranceB = 2;
aMetricParams.iType = ETypeNegativeImage;
aMetricParams.iMetricRange = metricRange;
aMetricParams.iTestCoordinates.iStartIndexX = 0;
aMetricParams.iTestCoordinates.iStartIndexY = 0;
aMetricParams.iTestCoordinates.iPixelsToGrabX = 2048;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 1536;
ALGO_Log_0("*************NEGATIVE METRIC TEST 1************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg1\\Input_rgb16_2048_1536.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg1\\Output1_rgb16_2048_1536.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************NEGATIVE METRIC TEST 2************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg1\\Input_rgb16_2048_1536.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg1\\Output2_rgb16_2048_1536.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************NEGATIVE METRIC TEST 3************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg1\\Input_rgb16_2048_1536.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg1\\Output3_rgb16_2048_1536.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************NEGATIVE METRIC TEST 4************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg2\\2592_1944_ColorTone_Normal.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg2\\2592_1944_ColorTone_Negative.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
ALGO_Log_0("*************NEGATIVE METRIC TEST 5************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg3\\Image_no_effect.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg3\\Image_negative_enabled.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************NEGATIVE METRIC TEST 6************ \n");
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg4\\Image_normal.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg4\\Image_negative.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************NEGATIVE METRIC TEST 7************ \n");
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg5\\Image_normal.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg5\\Image_negative.bmp");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************NEGATIVE METRIC TEST 8************ \n");
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg6\\Image_Normal.gam");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg6\\Image_Negative.gam");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************NEGATIVE METRIC TEST 9************ \n");
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\Negative\\neg7\\Image_normal.gam");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\Negative\\neg7\\Image_negative.gam");
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
return 0;
}
/**
* Spatial Similar Unit Test Cases.
*/
TInt32 test_metric_spatialsimilar_characterization(TUint8* aDirPath)
{
TAlgoError ret = EErrorNone;
TAlgoMetricParams aMetricParams;
TUint8 dir[128];
TUint8 dir1[128];
aMetricParams.iErrorTolerance.iErrorToleranceR = 1;
aMetricParams.iErrorTolerance.iErrorToleranceG = 1;
aMetricParams.iErrorTolerance.iErrorToleranceB = 1;
aMetricParams.iTestCoordinates.iStartIndexX = 0;
aMetricParams.iTestCoordinates.iStartIndexY = 0;
aMetricParams.iTestCoordinates.iPixelsToGrabX = 640;
aMetricParams.iTestCoordinates.iPixelsToGrabY = 480;
ALGO_Log_0("*************SPATIAL SIMILAR METRIC TEST 1************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\SpatialSimilar\\SS_IM1_Enable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\SpatialSimilar\\SS_IM1_Disable.bmp");
aMetricParams.iType = ETypeSpatialSimilar;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************SPATIAL SIMILAR METRIC TEST 2************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\SpatialSimilar\\SS_IM2_Enable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\SpatialSimilar\\SS_IM2_Disable.bmp");
aMetricParams.iType = ETypeSpatialSimilar;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************SPATIAL SIMILAR METRIC TEST 3************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\SpatialSimilar\\SS_IM3_Enable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\SpatialSimilar\\SS_IM3_Disable.bmp");
aMetricParams.iType = ETypeSpatialSimilar;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************SPATIAL SIMILAR METRIC TEST 4************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\SpatialSimilar\\SS_IM4_Enable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\SpatialSimilar\\SS_IM4_Disable.bmp");
aMetricParams.iType = ETypeSpatialSimilar;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************SPATIAL SIMILAR METRIC TEST 5************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\SpatialSimilar\\SS_IM5_Enable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\SpatialSimilar\\SS_IM5_Disable.bmp");
aMetricParams.iType = ETypeSpatialSimilar;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
ALGO_Log_0("*************SPATIAL SIMILAR METRIC TEST 6************ \n");
AlgoStrcpy(dir, aDirPath);
AlgoStrcat(dir, "\\SpatialSimilar\\SS_IM6_Enable.bmp");
AlgoStrcpy(dir1, aDirPath);
AlgoStrcat(dir1, "\\SpatialSimilar\\SS_IM6_Disable.bmp");
aMetricParams.iType = ETypeSpatialSimilar;
ret = ValidationMetricInterfaceWithFiles(NULL, NULL, dir, dir1, &aMetricParams );
Metrcis_Print_Result(ret);
return 0;
}
/**
* Validation Metric for the Solarize Effect (basic).
*
* @param aImageEffectDisable [TAlgoImage] The image with Effect Disable.
* @param aImageEffectEnable [TAlgoImage] The image with Effect Enable.
* @param aMetricParams [TAlgoMetricParams]The metric parameters to be applied.
*
* @return [TAlgoError] EErrorNone if the validation is passed.
*/
TAlgoError ValidationMetricSolarizeEffect_basic( const TAlgoImage* aImageEffectDisable,
const TAlgoImage* aImageEffectEnable,
const TAlgoMetricParams* aMetricParams )
{
TUint32 index = 0;
TReal64 negTolerance = 0;
TReal64 posTolerance = 0;
TInt32 colorBar_NbColon = 8;
TInt32 colorBar_ColonWidth = 0;
TUint8 disableFirstColon_white_PixelValue = 0, enableFirstColon_white_PixelValue = 0;
TUint8 disableLastColon_black_PixelValue = 0, enableLastColon_black_PixelValue = 0;
for( index=0; index<(aImageEffectDisable->iImageParams.iImageHeight *
aImageEffectDisable->iImageParams.iImageWidth); index++ )
{
aImageEffectDisable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectDisable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectDisable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectDisable->iImageData.iBChannel[index]);
aImageEffectEnable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectEnable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectEnable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectEnable->iImageData.iBChannel[index]);
}
if(aMetricParams->iTestCoordinates.iPixelsToGrabX != aImageEffectDisable->iImageParams.iImageWidth)
{
ALGO_Log_0("Error, need to work on the whole image (color bar) Width \n");
return EErrorNotValidated;
}
if(aMetricParams->iTestCoordinates.iPixelsToGrabY != aImageEffectDisable->iImageParams.iImageHeight)
{
ALGO_Log_0("Error, need to work on the whole image (color bar) Height \n");
return EErrorNotValidated;
}
if( (aMetricParams->iTestCoordinates.iStartIndexY != 0) || (aMetricParams->iTestCoordinates.iStartIndexX != 0) )
{
ALGO_Log_0("Error, need to work on the whole image (color bar) StartIndex\n");
return EErrorNotValidated;
}
colorBar_ColonWidth = aImageEffectDisable->iImageParams.iImageWidth / colorBar_NbColon;
// middle of thh colon and middle of the height
disableFirstColon_white_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableFirstColon_white_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableLastColon_black_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*(2*colorBar_NbColon-1)/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableLastColon_black_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*(2*colorBar_NbColon-1)/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
ALGO_Log_1("disableFirstColon_white_PixelValue = %d\n", disableFirstColon_white_PixelValue);
ALGO_Log_1("enableFirstColon_white_PixelValue = %d\n", enableFirstColon_white_PixelValue);
negTolerance = SOLARIZE_CHECK_NEG_THRESHOLD - ((SOLARIZE_CHECK_NEG_THRESHOLD * aMetricParams->iErrorTolerance.iErrorToleranceR)/100);
ALGO_Log_1("negTolerance = %10f\n", negTolerance);
ALGO_Log_1("disableLastColon_black_PixelValue = %d\n", disableLastColon_black_PixelValue);
ALGO_Log_1("enableLastColon_black_PixelValue = %d\n", enableLastColon_black_PixelValue);
posTolerance = SOLARIZE_CHECK_POS_THRESHOLD - ((SOLARIZE_CHECK_NEG_THRESHOLD * aMetricParams->iErrorTolerance.iErrorToleranceR)/100);
ALGO_Log_1("posTolerance = %10f\n", posTolerance);
if(
(enableFirstColon_white_PixelValue <= (disableFirstColon_white_PixelValue - negTolerance) )
&&
(enableLastColon_black_PixelValue >= (disableLastColon_black_PixelValue + posTolerance) )
)
{
return EErrorNone;
}
else
{
return EErrorNotValidated;
}
}
/**
* Validation Metric for the Gamma Effect basic.
*
* @param aImageEffectDisable [TAlgoImage] The image with Effect Disable.
* @param aImageEffectEnable [TAlgoImage] The image with Effect Enable.
* @param aMetricParams [TAlgoMetricParams]The metric parameters to be applied.
*
* @return [TAlgoError] EErrorNone if the validation is passed.
*/
TAlgoError ValidationMetricGammaEffect_basic( const TAlgoImage* aImageEffectDisable,
const TAlgoImage* aImageEffectEnable,
const TAlgoMetricParams* aMetricParams )
{
TUint32 index = 0;
TReal64 toleranceGamma = 0;
TInt32 colorBar_NbColon = 8;
TInt32 colorBar_ColonWidth = 0;
TUint8 disableColon_1_PixelValue = 0, enableColon_1_PixelValue = 0;
TUint8 disableColon_2_PixelValue = 0, enableColon_2_PixelValue = 0;
TUint8 disableColon_3_PixelValue = 0, enableColon_3_PixelValue = 0;
TUint8 disableColon_4_PixelValue = 0, enableColon_4_PixelValue = 0;
TUint8 disableColon_5_PixelValue = 0, enableColon_5_PixelValue = 0;
TUint8 disableColon_6_PixelValue = 0, enableColon_6_PixelValue = 0;
TUint8 disableColon_7_PixelValue = 0, enableColon_7_PixelValue = 0;
TUint8 disableColon_8_PixelValue = 0, enableColon_8_PixelValue = 0;
for( index=0; index<(aImageEffectDisable->iImageParams.iImageHeight *
aImageEffectDisable->iImageParams.iImageWidth); index++ )
{
aImageEffectDisable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectDisable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectDisable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectDisable->iImageData.iBChannel[index]);
aImageEffectEnable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectEnable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectEnable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectEnable->iImageData.iBChannel[index]);
}
if(aMetricParams->iTestCoordinates.iPixelsToGrabX != aImageEffectDisable->iImageParams.iImageWidth)
{
ALGO_Log_0("Error, need to work on the whole image (color bar) Width \n");
return EErrorNotValidated;
}
if(aMetricParams->iTestCoordinates.iPixelsToGrabY != aImageEffectDisable->iImageParams.iImageHeight)
{
ALGO_Log_0("Error, need to work on the whole image (color bar) Height \n");
return EErrorNotValidated;
}
if( (aMetricParams->iTestCoordinates.iStartIndexY != 0) || (aMetricParams->iTestCoordinates.iStartIndexX != 0) )
{
ALGO_Log_0("Error, need to work on the whole image (color bar) StartIndex\n");
return EErrorNotValidated;
}
colorBar_ColonWidth = aImageEffectDisable->iImageParams.iImageWidth / colorBar_NbColon;
// middle of thh colon and middle of the height
disableColon_1_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*1/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_1_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*1/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableColon_2_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*3/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_2_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*3/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableColon_3_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*5/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_3_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*5/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableColon_4_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*7/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_4_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*7/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableColon_5_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*9/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_5_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*9/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableColon_6_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*11/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_6_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*11/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableColon_7_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*13/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_7_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*13/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
disableColon_8_PixelValue = aImageEffectDisable->iImageData.iRChannel[ (colorBar_ColonWidth*15/2) + (aImageEffectDisable->iImageParams.iImageWidth * aImageEffectDisable->iImageParams.iImageHeight / 2)];
enableColon_8_PixelValue = aImageEffectEnable->iImageData.iRChannel[ (colorBar_ColonWidth*15/2) + (aImageEffectEnable->iImageParams.iImageWidth * aImageEffectEnable->iImageParams.iImageHeight / 2)];
ALGO_Log_1("disableColon_1_PixelValue = %d\n", disableColon_1_PixelValue);
ALGO_Log_1("enableColon_1_PixelValue = %d\n", enableColon_1_PixelValue);
ALGO_Log_1("disableColon_2_PixelValue = %d\n", disableColon_2_PixelValue);
ALGO_Log_1("enableColon_2_PixelValue = %d\n", enableColon_2_PixelValue);
ALGO_Log_1("disableColon_3_PixelValue = %d\n", disableColon_3_PixelValue);
ALGO_Log_1("enableColon_3_PixelValue = %d\n", enableColon_3_PixelValue);
ALGO_Log_1("disableColon_4_PixelValue = %d\n", disableColon_4_PixelValue);
ALGO_Log_1("enableColon_4_PixelValue = %d\n", enableColon_4_PixelValue);
ALGO_Log_1("disableColon_5_PixelValue = %d\n", disableColon_5_PixelValue);
ALGO_Log_1("enableColon_5_PixelValue = %d\n", enableColon_5_PixelValue);
ALGO_Log_1("disableColon_6_PixelValue = %d\n", disableColon_6_PixelValue);
ALGO_Log_1("enableColon_6_PixelValue = %d\n", enableColon_6_PixelValue);
ALGO_Log_1("disableColon_7_PixelValue = %d\n", disableColon_7_PixelValue);
ALGO_Log_1("enableColon_7_PixelValue = %d\n", enableColon_7_PixelValue);
ALGO_Log_1("disableColon_8_PixelValue = %d\n", disableColon_8_PixelValue);
ALGO_Log_1("enableColon_8_PixelValue = %d\n", enableColon_8_PixelValue);
toleranceGamma = GAMMA_THRESHOLD - ((GAMMA_THRESHOLD * aMetricParams->iErrorTolerance.iErrorToleranceR)/100);
ALGO_Log_1("toleranceGamma = %10f\n", toleranceGamma);
if(
(enableColon_2_PixelValue <= (disableColon_2_PixelValue - toleranceGamma) )
&&
(enableColon_3_PixelValue <= (disableColon_3_PixelValue - toleranceGamma) )
&&
(enableColon_4_PixelValue <= (disableColon_4_PixelValue - toleranceGamma) )
&&
(enableColon_5_PixelValue <= (disableColon_5_PixelValue - toleranceGamma) )
&&
(enableColon_6_PixelValue <= (disableColon_6_PixelValue - toleranceGamma) )
&&
(enableColon_7_PixelValue <= (disableColon_7_PixelValue - toleranceGamma) )
)
{
return EErrorNone;
}
else
{
return EErrorNotValidated;
}
}
/**
* Validation Metric for the ExposureValue.
*
* @param aImageEffectDisable [TAlgoImage] The image with Effect Disable.
* @param aImageEffectEnable [TAlgoImage] The image with Effect Enable.
* @param aMetricParams [TAlgoMetricParams]The metric parameters to be applied.
*
* @return [TAlgoError] EErrorNone if the validation is passed.
*/
TAlgoError ValidationMetricExposureValue( const TAlgoImage* aImageEffectDisable,
const TAlgoImage* aImageEffectEnable,
const TAlgoMetricParams* aMetricParams )
{
TUint32 i = 0;
TUint32 j = 0;
TUint32 index = 0;
TReal64 Avg_Disable = 0;
TReal64 Avg_Enable = 0;
TAlgoParamExposureValue *paramExposureValue = (TAlgoParamExposureValue*)aMetricParams->iParams;
TUint32 startingOffset = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth
+ aMetricParams->iTestCoordinates.iStartIndexX;
TUint32 offset = (aImageEffectDisable->iImageParams.iImageWidth - aMetricParams->iTestCoordinates.iPixelsToGrabX);
ALGO_Log_1("entering %s\n", __FUNCTION__);
ALGO_Log_3("ToleranceR = %f, ToleranceG = %f, ToleranceB = %f\n", aMetricParams->iErrorTolerance.iErrorToleranceR, aMetricParams->iErrorTolerance.iErrorToleranceG, aMetricParams->iErrorTolerance.iErrorToleranceB);
switch(paramExposureValue->iExpoValueType)
{
case EExpoValue_Metering:
{
}
break;
case EExpoValue_EVCompensation:
case EExpoValue_Senstivity:
{
//Getting the luma component for both images in the R Channel.
for( index=0; index<(aImageEffectDisable->iImageParams.iImageHeight *
aImageEffectDisable->iImageParams.iImageWidth); index++)
{
aImageEffectDisable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectDisable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectDisable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectDisable->iImageData.iBChannel[index]);
aImageEffectEnable->iImageData.iRChannel[index] = (TUint8)(LUMINANCE_R_COEF * aImageEffectEnable->iImageData.iRChannel[index]
+ LUMINANCE_G_COEF * aImageEffectEnable->iImageData.iGChannel[index]
+ LUMINANCE_B_COEF * aImageEffectEnable->iImageData.iBChannel[index]);
}
//Calculating the average of luma components of both images.
index = startingOffset;
for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabY; i++ )
{
for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabX; j++)
{
Avg_Disable = Avg_Disable + aImageEffectDisable->iImageData.iRChannel[index];
Avg_Enable = Avg_Enable + aImageEffectEnable->iImageData.iRChannel[index];
index++;
}
index = index + offset;
}
Avg_Disable = Avg_Disable/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY);
Avg_Enable = Avg_Enable/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY);
//Ratio Test
if(((Avg_Enable/Avg_Disable) > 1.5) && ((Avg_Enable/Avg_Disable) < 2.5))
{
ALGO_Log_0("ExposureValue Metric : PASSED in Ratio Test \n\n");
ALGO_Log_1("ExposureValue Metric : Avg_Enable/Avg_Disable = %f\n\n", (Avg_Enable/Avg_Disable));
}
else
{
ALGO_Log_0("ExposureValue Metric : FAILED in Ratio Test \n\n");
ALGO_Log_1("ExposureValue Metric : Avg_Enable/Avg_Disable = %f\n\n", (Avg_Enable/Avg_Disable));
}
ALGO_Log_2("ExposureValue Metric : Avg_Disable = %.3f, Avg_Enable = %.3f\n\n", Avg_Disable, Avg_Enable);
ALGO_Log_2("ExposureValue Metric : ExposureValue_Disable = %f, ExposureValue_Enable = %f\n\n", paramExposureValue->iExposureValue_Disable, paramExposureValue->iExposureValue_Enable);
if(((Avg_Disable < Avg_Enable) && (paramExposureValue->iExposureValue_Disable < paramExposureValue->iExposureValue_Enable )) ||
((Avg_Disable > Avg_Enable) && (paramExposureValue->iExposureValue_Disable > paramExposureValue->iExposureValue_Enable )))
{
return EErrorNone;
}
else
{
return EErrorNotValidated;
}
}
//break; //set in comment to avoid warnings
// break not needed because of returns above
// when changing above code, break might be required
case EExpoValue_ApertureFNumber:
{
}
break;
case EExpoValue_ApertureAuto:
{
}
break;
case EExpoValue_ShutterSpeedMsec:
{
}
break;
case EExpoValue_ShutterSpeedAuto:
{
}
break;
case EExpoValue_SenstivityAuto:
{
}
break;
default:
{
return EErrorNotSupported;
}
}
ALGO_Log_2("ExposureValue Metric : iExposureValue_Disable %d, iExposureValue_Enable %d\n\n", paramExposureValue->iExposureValue_Disable, paramExposureValue->iExposureValue_Enable);
return EErrorNotValidated;
}
