/** * To calculate the image vertical pixel differences R * * @param aImage [TAlgoImage] Image with Channel. * @param aPixelDiffR [TReal64*] Vertical pixel difference of Channel R. * @param aTestCoordinates [TAlgoImageTestCoordinates*] TestCoordinates. * * @return [TAlgoError] EErrorNone if the differences is computed successfully. */ TAlgoError CalculateImageVerticalDiff_R( const TAlgoImage* aImage, TReal64* aPixelDiffR, const TAlgoImageTestCoordinates* aTestCoordinates) { TUint32 width = 0; TUint32 height = 0; TUint32 index = 0; TUint32 counter = 0; *aPixelDiffR = 0; for (height = 0; height < aImage->iImageParams.iImageHeight; height++) { for (width = 0; width < aImage->iImageParams.iImageWidth; width++) { index = height * aImage->iImageParams.iImageWidth + width; if ( (index > aImage->iImageParams.iImageWidth) && (index - (height * aImage->iImageParams.iImageWidth) > aTestCoordinates->iStartIndexX) && (index - (height * aImage->iImageParams.iImageWidth) <= aTestCoordinates->iStartIndexX + aTestCoordinates->iPixelsToGrabX) && (height > aTestCoordinates->iStartIndexY) && (height <= aTestCoordinates->iStartIndexY + aTestCoordinates->iPixelsToGrabY) ) { *aPixelDiffR += ABS(aImage->iImageData.iRChannel[index] - aImage->iImageData.iRChannel[index-aImage->iImageParams.iImageWidth]); counter++; } } } ALGO_Log_1("fct %s\n", __FUNCTION__); ALGO_Log_1("counter = %d\n", counter); ALGO_Log_1("iPixelsToGrabX * iPixelsToGrabY = %d\n", aTestCoordinates->iPixelsToGrabX * aTestCoordinates->iPixelsToGrabY); ALGO_Log_2("iPixelsToGrabX = %d iPixelsToGrabY = %d\n", aTestCoordinates->iPixelsToGrabX, aTestCoordinates->iPixelsToGrabY); return EErrorNone; }
/** * 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; }
/** * 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; }
/** * Validation Metric for the Contrast 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 ValidationMetricContrastEffect( const TAlgoImage* aImageEffectDisable, const TAlgoImage* aImageEffectEnable, const TAlgoMetricParams* aMetricParams ) { #if 1 TUint32 index = 0; TUint32 x = 0; TUint32 y = 0; TUint32 startingOffset = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth + aMetricParams->iTestCoordinates.iStartIndexX; TUint32 offset = (aImageEffectDisable->iImageParams.iImageWidth - aMetricParams->iTestCoordinates.iPixelsToGrabX); TUint8 *iR = aImageEffectDisable->iImageData.iRChannel + startingOffset; TUint8 *oR = aImageEffectEnable->iImageData.iRChannel + startingOffset; //TInt32 DiffInput = 0, DiffOutput = 0; // don't use TInt32 but TReal64 as for big images we can have overflow TReal64 DiffInput = 0, DiffOutput = 0; TReal64 SDInput = 0, SDOutput = 0, SDDiff = 0; TReal64 tolerance = 0; TUint32 mean_input = 0, mean_output = 0; TAlgoParamContrast *paramContrast = (TAlgoParamContrast*)aMetricParams->iParams; 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_2("Contrast Metric : iPrContrast_1 %d, iPrContrast_2 %d\n\n", paramContrast->iPrContrast_1, paramContrast->iPrContrast_2); 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]); } //ALGO_Log_2("LumaInputMean = %10d, LumaOutputMean = %10d\n", InputMean, OutputMean); mean_input = 0; mean_output = 0; iR = aImageEffectDisable->iImageData.iRChannel + startingOffset; oR = aImageEffectEnable->iImageData.iRChannel + startingOffset; for(y=0; y < aMetricParams->iTestCoordinates.iPixelsToGrabY - 1; y++) { for (x=0; x < aMetricParams->iTestCoordinates.iPixelsToGrabX - 1; x++) { mean_input += *iR; mean_output += *oR; iR++; oR++; } iR += offset; oR += offset; } mean_input = mean_input /(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY); mean_output = mean_output /(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY); ALGO_Log_2("mean_input = %d, mean_output = %d\n", mean_input, mean_output); iR = aImageEffectDisable->iImageData.iRChannel + startingOffset; oR = aImageEffectEnable->iImageData.iRChannel + startingOffset; for(y=0; y < aMetricParams->iTestCoordinates.iPixelsToGrabY - 1; y++) { for (x=0; x < aMetricParams->iTestCoordinates.iPixelsToGrabX - 1; x++) { DiffInput = DiffInput + ((*iR - mean_input) * (*iR - mean_input)); DiffOutput = DiffOutput + ((*oR - mean_output) * (*oR - mean_output)); iR++; oR++; } iR += offset; oR += offset; } SDInput = SQUAREROOT(DiffInput/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY)); SDOutput = SQUAREROOT(DiffOutput/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY)); ALGO_Log_2("SDInput = %10f, SDOutput = %10f\n", SDInput, SDOutput); tolerance = (aMetricParams->iErrorTolerance.iErrorToleranceR * CONTRAST_THRESHOLD)/100; ALGO_Log_2("CONTRAST_THRESHOLD = %d, (CONTRAST_THRESHOLD - tolerance) = %10f\n", CONTRAST_THRESHOLD, (CONTRAST_THRESHOLD - tolerance)); if(paramContrast->iPrContrast_1 < paramContrast->iPrContrast_2) { SDDiff = SDOutput - SDInput; } else { SDDiff = SDInput - SDOutput; } ALGO_Log_1("SDDiff = %10f\n", SDDiff); if( SDDiff > (CONTRAST_THRESHOLD - tolerance)) { return EErrorNone; } else { return EErrorNotValidated; } #else TReal64 R_Avg_Im1 = 0; TReal64 G_Avg_Im1 = 0; TReal64 B_Avg_Im1 = 0; TReal64 Intensity_Im1 = 0; TReal64 R_Avg_Im2 = 0; TReal64 G_Avg_Im2 = 0; TReal64 B_Avg_Im2 = 0; TReal64 Intensity_Im2 = 0; 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 ); Intensity_Im1 = (R_Avg_Im1 + G_Avg_Im1 + B_Avg_Im1)/3.255; Intensity_Im2 = (R_Avg_Im2 + G_Avg_Im2 + B_Avg_Im2)/3.255; ALGO_Log_2("Intensity_Im1 = %10f, Intensity_Im2 %10f\n", Intensity_Im1, Intensity_Im2); if( Intensity_Im1 > Intensity_Im2) { return EErrorNone; } else { return EErrorNotValidated; } #endif }
/** * 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; }
/** * Validation Metric for the Auto Focus 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 ValidationMetricAutoFocusEffect( const TAlgoImage* aImageEffectDisable, const TAlgoImage* aImageEffectEnable, const TAlgoMetricParams* aMetricParams ) { TReal64 HorizPixelDiffEffectEnableR = 0; //TReal64 HorizPixelDiffEffectEnableG = 0; //TReal64 HorizPixelDiffEffectEnableB = 0; TReal64 VertPixelDiffEffectEnableR = 0; //TReal64 VertPixelDiffEffectEnableG = 0; //TReal64 VertPixelDiffEffectEnableB = 0; TReal64 HorizPixelDiffEffectDisableR = 0; //TReal64 HorizPixelDiffEffectDisableG = 0; //TReal64 HorizPixelDiffEffectDisableB = 0; TReal64 VertPixelDiffEffectDisableR = 0; //TReal64 VertPixelDiffEffectDisableG = 0; //TReal64 VertPixelDiffEffectDisableB = 0; //TReal64 HorizPixelDiffEffectEnableLuminance = 0; //TReal64 VertPixelDiffEffectEnableLuminance = 0; //TReal64 HorizPixelDiffEffectDisableLuminance = 0; //TReal64 VertPixelDiffEffectDisableLuminance = 0; //TReal64 HorizPixelDiffEffectEnableLuminanceFullImage = 0; //TReal64 VertPixelDiffEffectEnableLuminanceFullImage = 0; //TReal64 HorizPixelDiffEffectDisableLuminanceFullImage = 0; //TReal64 VertPixelDiffEffectDisableLuminanceFullImage = 0; TReal64 tolerance = 0; TReal64 threshold = 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); ALGO_Log_2("iPixelsToGrabX = %d, iPixelsToGrabY = %d\n", aMetricParams->iTestCoordinates.iPixelsToGrabX, aMetricParams->iTestCoordinates.iPixelsToGrabY); /* CalculateImageHorizontalDiff( aImageEffectEnable, &HorizPixelDiffEffectEnableR, &HorizPixelDiffEffectEnableG, &HorizPixelDiffEffectEnableB, &HorizPixelDiffEffectEnableLuminance, &aMetricParams->iTestCoordinates ); CalculateImageVerticalDiff( aImageEffectEnable, &VertPixelDiffEffectEnableR, &VertPixelDiffEffectEnableG, &VertPixelDiffEffectEnableB, &VertPixelDiffEffectEnableLuminance, &aMetricParams->iTestCoordinates ); CalculateImageHorizontalDiff( aImageEffectDisable, &HorizPixelDiffEffectDisableR, &HorizPixelDiffEffectDisableG, &HorizPixelDiffEffectDisableB, &HorizPixelDiffEffectDisableLuminance, &aMetricParams->iTestCoordinates ); CalculateImageVerticalDiff( aImageEffectDisable, &VertPixelDiffEffectDisableR, &VertPixelDiffEffectDisableG, &VertPixelDiffEffectDisableB, &VertPixelDiffEffectDisableLuminance, &aMetricParams->iTestCoordinates ); ALGO_Log_1("HorizPixelDiffEffectEnableLuminance/HorizPixelDiffEffectDisableLuminance = %1.2lf\n\n", (double)(HorizPixelDiffEffectEnableLuminance/HorizPixelDiffEffectDisableLuminance)); ALGO_Log_1("VertPixelDiffEffectEnableLuminance/VertPixelDiffEffectDisableLuminance = %1.2lf\n\n", (double)(VertPixelDiffEffectEnableLuminance/VertPixelDiffEffectDisableLuminance)); tolerance = ((aMetricParams->iErrorTolerance.iErrorToleranceR) * (AUTO_FOCUS_THRESHOLD - 1))/100; threshold = AUTO_FOCUS_THRESHOLD - tolerance; ALGO_Log_1("threshold = %f\n", threshold); if(((HorizPixelDiffEffectEnableLuminance/HorizPixelDiffEffectDisableLuminance) > threshold) && ((VertPixelDiffEffectEnableLuminance/VertPixelDiffEffectDisableLuminance) > threshold)) { return EErrorNone; } else { return EErrorNotValidated; } */ { TAlgoError errorCode = EErrorNone ; errorCode = GetLumaOn_R_Channel_And_Normalize(aImageEffectDisable, aImageEffectEnable); if(errorCode!= EErrorNone) { return EErrorNotValidated; } } CalculateImageHorizontalDiff_R( aImageEffectEnable, &HorizPixelDiffEffectEnableR, &aMetricParams->iTestCoordinates ); CalculateImageVerticalDiff_R( aImageEffectEnable, &VertPixelDiffEffectEnableR, &aMetricParams->iTestCoordinates ); CalculateImageHorizontalDiff_R( aImageEffectDisable, &HorizPixelDiffEffectDisableR, &aMetricParams->iTestCoordinates ); CalculateImageVerticalDiff_R( aImageEffectDisable, &VertPixelDiffEffectDisableR, &aMetricParams->iTestCoordinates ); ALGO_Log_1("HorizPixelDiffEffectDisableR = %1.2lf\n\n", (double)(HorizPixelDiffEffectDisableR)); ALGO_Log_1("VertPixelDiffEffectDisableR = %1.2lf\n\n", (double)(VertPixelDiffEffectDisableR)); ALGO_Log_1("HorizPixelDiffEffectEnableR = %1.2lf\n\n", (double)(HorizPixelDiffEffectEnableR)); ALGO_Log_1("VertPixelDiffEffectEnableR = %1.2lf\n\n", (double)(VertPixelDiffEffectEnableR)); ALGO_Log_1("HorizPixelDiffEffectEnableR/HorizPixelDiffEffectDisableR = %1.2lf\n\n", (double)(HorizPixelDiffEffectEnableR/HorizPixelDiffEffectDisableR)); ALGO_Log_1("VertPixelDiffEffectEnableR/VertPixelDiffEffectDisableR = %1.2lf\n\n", (double)(VertPixelDiffEffectEnableR/VertPixelDiffEffectDisableR)); tolerance = ((aMetricParams->iErrorTolerance.iErrorToleranceR) * (AUTO_FOCUS_THRESHOLD - 1))/100; threshold = AUTO_FOCUS_THRESHOLD - tolerance; ALGO_Log_1("AUTO_FOCUS_THRESHOLD = %f\n", AUTO_FOCUS_THRESHOLD); ALGO_Log_1("tolerance_param in percent = %d\n", aMetricParams->iErrorTolerance.iErrorToleranceR); ALGO_Log_1("threshold = %f\n", threshold); if(((HorizPixelDiffEffectEnableR/HorizPixelDiffEffectDisableR) > threshold) && ((VertPixelDiffEffectEnableR/VertPixelDiffEffectDisableR) > threshold)) { return EErrorNone; } else { return EErrorNotValidated; } }
TAlgoError ValidationMetric270degreesRotationEffect( const TAlgoImage* aImageEffectDisable, const TAlgoImage* aImageEffectEnable, const TAlgoMetricParams* aMetricParams ) { TUint32 i = 0; TUint32 j = 0; TUint32 indexDisable =0; TUint32 indexEnable =0; TInt32 error1 = 0; TInt32 error_mean_row = 0, error_mean_col = 0, error_mean_row_total = 0, error_mean_col_total = 0; TInt32 deviationCol = 0; TInt32 deviationRow = 0; TUint32 colonimg1 = 0; TUint32 colonimg2 = 0; TUint32 rowimg1 = 0; TUint32 rowimg2 = 0; #ifdef ROTATION_OLD_WAY TReal64 toleranceCol = 0; TReal64 toleranceRow = 0; #endif TInt32 colonDiff = 0; TInt32 rowDiff = 0; TUint32 startingOffsetDisable = 0, startingOffsetEnable = 0; TUint32 EnableWidthWorking = 0; TUint32 EnableHeightWorking = 0; ALGO_Log_1("entering rotation %s\n", __FUNCTION__); ALGO_Log_2("iStartIndexX %d , iStartIndexY %d\n", aMetricParams->iTestCoordinates.iStartIndexX, aMetricParams->iTestCoordinates.iStartIndexY); ALGO_Log_2("iPixelsToGrabX %d , iPixelsToGrabY %d\n", aMetricParams->iTestCoordinates.iPixelsToGrabX, aMetricParams->iTestCoordinates.iPixelsToGrabY); ALGO_Log_4("Disable width x height = %d x %d, stride %d, sliceheight %d\n", aImageEffectDisable->iImageParams.iImageWidth, aImageEffectDisable->iImageParams.iImageHeight, aImageEffectDisable->iImageParams.iImageStride, aImageEffectDisable->iImageParams.iImageSliceHeight); ALGO_Log_4("Enable width x height = %d x %d, stride %d, sliceheight %d\n", aImageEffectEnable->iImageParams.iImageWidth, aImageEffectEnable->iImageParams.iImageHeight, aImageEffectEnable->iImageParams.iImageStride, aImageEffectEnable->iImageParams.iImageSliceHeight); EnableWidthWorking = aImageEffectDisable->iImageParams.iImageHeight; ALGO_Log_1("EnableWidthWorking %d\n", EnableWidthWorking); EnableHeightWorking = aImageEffectDisable->iImageParams.iImageWidth; ALGO_Log_1("EnableHeightWorking %d\n", EnableHeightWorking); startingOffsetDisable = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth + aMetricParams->iTestCoordinates.iStartIndexX; startingOffsetEnable = EnableWidthWorking * (EnableHeightWorking - aMetricParams->iTestCoordinates.iStartIndexX -1) + aMetricParams->iTestCoordinates.iStartIndexY; error_mean_col = 0; error_mean_col_total = 0; for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabX; i++ ) { indexDisable = startingOffsetDisable;// First Column. indexEnable = startingOffsetEnable;// row. for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabY; j++) { colonimg1 = colonimg1 + aImageEffectDisable->iImageData.iRChannel[indexDisable]; rowimg2 = rowimg2 + aImageEffectEnable->iImageData.iRChannel[indexEnable]; indexDisable = indexDisable + aImageEffectDisable->iImageParams.iImageWidth; indexEnable++; } colonimg1 = colonimg1/aMetricParams->iTestCoordinates.iPixelsToGrabX; rowimg2 = rowimg2/aMetricParams->iTestCoordinates.iPixelsToGrabX; rowDiff = colonimg1 - rowimg2; error1 = ABS(rowDiff); error_mean_col_total += error1; if(error1 > ROTATION_THRESHOLD) { #ifdef ROTATION_OLD_WAY ALGO_Log_3("\t\t deviationCol++, w_i=%d, error1 = %d > %d = ROTATION_THRESHOLD\n", i, error1, ROTATION_THRESHOLD); #endif deviationCol++; error_mean_col += error1; } colonimg1 = 0; rowimg2 = 0; startingOffsetDisable++; // Next Column startingOffsetEnable = startingOffsetEnable - EnableWidthWorking; // Next Row } if(deviationCol != 0) { error_mean_col = error_mean_col / deviationCol; } error_mean_col_total = error_mean_col_total / i; startingOffsetDisable = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth + aMetricParams->iTestCoordinates.iStartIndexX; startingOffsetEnable = EnableWidthWorking * (EnableHeightWorking - aMetricParams->iTestCoordinates.iStartIndexX - 1) + aMetricParams->iTestCoordinates.iStartIndexY; error_mean_row = 0; error_mean_row_total = 0; for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabY; i++ ) { indexDisable = startingOffsetDisable;// First Row. indexEnable = startingOffsetEnable;// Column. for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabX; j++) { rowimg1 = rowimg1 + aImageEffectDisable->iImageData.iRChannel[indexDisable]; colonimg2 = colonimg2 + aImageEffectEnable->iImageData.iRChannel[indexEnable]; indexDisable ++; indexEnable = indexEnable - EnableWidthWorking; } rowimg1 = rowimg1/aMetricParams->iTestCoordinates.iPixelsToGrabY; colonimg2 = colonimg2/aMetricParams->iTestCoordinates.iPixelsToGrabY; colonDiff = colonimg2 - rowimg1; error1 = ABS(colonDiff); error_mean_row_total += error1; if(error1 > ROTATION_THRESHOLD) { #ifdef ROTATION_OLD_WAY ALGO_Log_3("\t\t deviationRow++, h_i=%d, error1 = %d > %d = ROTATION_THRESHOLD\n", i, error1, ROTATION_THRESHOLD); #endif deviationRow++; error_mean_row += error1; } rowimg1 = 0; colonimg2 = 0; startingOffsetDisable = startingOffsetDisable + aImageEffectDisable->iImageParams.iImageWidth; // Next Row startingOffsetEnable++; // Column } if(deviationRow != 0) { error_mean_row = error_mean_row / deviationRow; } error_mean_row_total = error_mean_row_total / i; #ifdef ROTATION_OLD_WAY toleranceCol = ( aMetricParams->iErrorTolerance.iErrorToleranceR * aMetricParams->iTestCoordinates.iPixelsToGrabX )/100; toleranceRow = ( aMetricParams->iErrorTolerance.iErrorToleranceR * aMetricParams->iTestCoordinates.iPixelsToGrabY )/100; ALGO_Log_4("deviationCol = %10d, deviationRow = %10d, toleranceCol = %10f, toleranceRow = %10f\n", deviationCol, deviationRow, toleranceCol, toleranceRow); ALGO_Log_3("error_mean_col = %d, error_mean_row = %d, ROTATION_THRESHOLD = %d\n", error_mean_col, error_mean_row, ROTATION_THRESHOLD); if((deviationCol <= toleranceCol)&&(deviationRow <= toleranceRow)) { return EErrorNone; } else { return EErrorNotValidated;; } #else ALGO_Log_3("error_mean_col_total = %d, error_mean_row_total = %d, ROTATION_THRESHOLD_TOTAL = %d\n", error_mean_col_total, error_mean_row_total, ROTATION_THRESHOLD_TOTAL); if((error_mean_col_total <= ROTATION_THRESHOLD_TOTAL)&&(error_mean_row_total <= ROTATION_THRESHOLD_TOTAL)) { return EErrorNone; } else { return EErrorNotValidated;; } #endif }
/** * Validation Metric for the Negative 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 ValidationMetricNegativeEffect( const TAlgoImage* aImageEffectDisable, const TAlgoImage* aImageEffectEnable, const TAlgoMetricParams* aMetricParams ) { #if 1 TUint32 i = 0; TUint32 j = 0; TUint32 index = 0; TUint32 deviation = 0; TReal64 tolerance = 0; TReal64 deltaR = 0; TReal64 deltaG = 0; TReal64 deltaB = 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); index = startingOffset; for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabY; i++ ) { for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabX; j++) { deltaR = ABS((255 - aImageEffectEnable->iImageData.iRChannel[index]) - (aImageEffectDisable->iImageData.iRChannel[index])); deltaG = ABS((255 - aImageEffectEnable->iImageData.iGChannel[index]) - (aImageEffectDisable->iImageData.iGChannel[index])); deltaB = ABS((255 - aImageEffectEnable->iImageData.iBChannel[index]) - (aImageEffectDisable->iImageData.iBChannel[index])); if((deltaR > NEGATIVE_THRESHOLD) || (deltaG > NEGATIVE_THRESHOLD) || (deltaB > NEGATIVE_THRESHOLD)) { deviation++; } index++; } index = index + offset; } tolerance = ( aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY * aMetricParams->iErrorTolerance.iErrorToleranceR ) / 100; ALGO_Log_2("deviation = %d, Tolerance = %f\n", deviation, tolerance); if(deviation <= (tolerance)) { return EErrorNone; } else { return EErrorNotValidated; } #else //TUint32 loop = 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 ); if(((R_Avg_Im1 < (aImageEffectDisable->iImageParams.iBitMaxR/2 - aMetricParams->iMetricRange.iRangeR)) || (R_Avg_Im1 > (aImageEffectDisable->iImageParams.iBitMaxR/2 + aMetricParams->iMetricRange.iRangeR))) && ((G_Avg_Im1 < (aImageEffectDisable->iImageParams.iBitMaxG/2 - aMetricParams->iMetricRange.iRangeG)) || (G_Avg_Im1 > (aImageEffectDisable->iImageParams.iBitMaxG/2 + aMetricParams->iMetricRange.iRangeG))) && ((B_Avg_Im1 < (aImageEffectDisable->iImageParams.iBitMaxB/2 - aMetricParams->iMetricRange.iRangeB)) || (B_Avg_Im1 > (aImageEffectDisable->iImageParams.iBitMaxB/2 + aMetricParams->iMetricRange.iRangeB)))) { if((ABS(R_Avg_Im1 - (aImageEffectDisable->iImageParams.iBitMaxR - R_Avg_Im2)) <= aMetricParams->iErrorTolerance.iErrorToleranceR ) && (ABS(G_Avg_Im1 - (aImageEffectDisable->iImageParams.iBitMaxG - G_Avg_Im2)) <= aMetricParams->iErrorTolerance.iErrorToleranceG ) && (ABS(B_Avg_Im1 - (aImageEffectDisable->iImageParams.iBitMaxB - B_Avg_Im2)) <= aMetricParams->iErrorTolerance.iErrorToleranceB )) //if((R_Avg_Im1 == 31 - R_Avg_Im2) & (G_Avg_Im1 == 63 - G_Avg_Im2) & (B_Avg_Im1 == 31 - B_Avg_Im2)) { return EErrorNone; } else { return EErrorNotValidated; } } else { return EErrorImageNotRelevant; } #endif }
/** * Validation Metric for the Solarize 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 ValidationMetricSolarizeEffect( const TAlgoImage* aImageEffectDisable, const TAlgoImage* aImageEffectEnable, const TAlgoMetricParams* aMetricParams ) { #if 1 TUint32 i = 0; TUint32 j = 0; TUint32 index = 0; TUint32 index1 = 0; TInt32 negCheck = 0; TInt32 posCheck = 0; //TUint32 x = 0; //TUint32 y = 0; TReal64 negTolerance = 0; TReal64 posTolerance = 0; TReal64 colonCurrentRImg1 = 0; TReal64 colonCurrentRImg2 = 0; TReal64 colonPreviousImg1 = 0; TReal64 colonPreviousImg2 = 0; TInt32 posDeviationImg1 = 0; TInt32 negDeviationImg1 = 0; TInt32 posDeviationImg2 = 0; TInt32 negDeviationImg2 = 0; TUint32 startingOffset = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth + aMetricParams->iTestCoordinates.iStartIndexX; 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); 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]); } index1 = startingOffset; index = index1; for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabX; i=i+10 ) { for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabY; j++) { colonCurrentRImg1 = colonCurrentRImg1 + aImageEffectDisable->iImageData.iRChannel[index]; index = index + aImageEffectDisable->iImageParams.iImageWidth; } colonCurrentRImg1 = colonCurrentRImg1/aMetricParams->iTestCoordinates.iPixelsToGrabY; if((colonCurrentRImg1 - colonPreviousImg1) > SOLARIZE_THRESHOLD) { posDeviationImg1++; colonPreviousImg1 = colonCurrentRImg1; } if((colonPreviousImg1 - colonCurrentRImg1) > SOLARIZE_THRESHOLD) { negDeviationImg1++; colonPreviousImg1 = colonCurrentRImg1; } colonCurrentRImg1 = 0; index1 = index1 + 10; index = index1; } index1 = startingOffset; index = index1; for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabX; i=i+10 ) { for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabY; j++) { colonCurrentRImg2 = colonCurrentRImg2 + aImageEffectEnable->iImageData.iRChannel[index]; index = index + aImageEffectEnable->iImageParams.iImageWidth; } colonCurrentRImg2 = colonCurrentRImg2/aMetricParams->iTestCoordinates.iPixelsToGrabY; if((colonCurrentRImg2 - colonPreviousImg2) > SOLARIZE_THRESHOLD) { posDeviationImg2++; colonPreviousImg2 = colonCurrentRImg2; } if((colonPreviousImg2 - colonCurrentRImg2) > SOLARIZE_THRESHOLD) { negDeviationImg2++; colonPreviousImg2 = colonCurrentRImg2; } colonCurrentRImg2 = 0; index1 = index1 + 10; index = index1; } ALGO_Log_2("posDeviationImg1 = %2d, negDeviationImg1 = %2d\n", posDeviationImg1, negDeviationImg1); ALGO_Log_2("posDeviationImg2 = %2d, negDeviationImg2 = %2d\n", posDeviationImg2, negDeviationImg2); negTolerance = SOLARIZE_CHECK_NEG_THRESHOLD - ((SOLARIZE_CHECK_NEG_THRESHOLD * aMetricParams->iErrorTolerance.iErrorToleranceR)/100); posTolerance = SOLARIZE_CHECK_POS_THRESHOLD - ((SOLARIZE_CHECK_NEG_THRESHOLD * aMetricParams->iErrorTolerance.iErrorToleranceR)/100); negCheck =(negDeviationImg2 - negDeviationImg1); posCheck =(posDeviationImg1 - posDeviationImg2); if((negCheck > negTolerance) && (posCheck > posTolerance)) { return EErrorNone; } else { return EErrorNotValidated; } #else TUint32 index = 0; TUint32 x = 0; TUint32 y = 0; TUint32 InputMean = 0; TUint32 OutputMean = 0; TUint32 startingOffset = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth + aMetricParams->iTestCoordinates.iStartIndexX; TUint32 offset = (aImageEffectDisable->iImageParams.iImageWidth - aMetricParams->iTestCoordinates.iPixelsToGrabX); TUint8 *iR = aImageEffectDisable->iImageData.iRChannel + startingOffset; TUint8 *oR = aImageEffectEnable->iImageData.iRChannel + startingOffset; 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); for( index=0; index<(aImageEffectDisable->iImageParams.iImageHeight * aImageEffectDisable->iImageParams.iImageWidth); index++ ) { aImageEffectDisable->iImageData.iRChannel[index] = 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] = LUMINANCE_R_COEF * aImageEffectEnable->iImageData.iRChannel[index] + LUMINANCE_G_COEF * aImageEffectEnable->iImageData.iGChannel[index] + LUMINANCE_B_COEF * aImageEffectEnable->iImageData.iBChannel[index]; } for(y=0; y < aMetricParams->iTestCoordinates.iPixelsToGrabY - 1; y++) { for (x=0; x < aMetricParams->iTestCoordinates.iPixelsToGrabX - 1; x++) { if(*iR < 128) { *iR = (*iR) * 2; } else { *iR = 512 - ((*iR) * 2); } InputMean = InputMean + *iR; OutputMean = OutputMean + *oR; iR++; oR++; } iR += offset; oR += offset; } InputMean = InputMean/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY); OutputMean = OutputMean/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY); ALGO_Log_2("LumaInputMean = %10d, LumaOutputMean = %10d\n", InputMean, OutputMean); if( InputMean/OutputMean > 2) { return EErrorNone; } else { return EErrorNotValidated; } //////////////////////////////////////Second Approach////////////////////////////////////// TReal64 R_Avg_Im1 = 0; TReal64 G_Avg_Im1 = 0; TReal64 B_Avg_Im1 = 0; TReal64 Intensity_Im1 = 0; TReal64 R_Avg_Im2 = 0; TReal64 G_Avg_Im2 = 0; TReal64 B_Avg_Im2 = 0; TReal64 Intensity_Im2 = 0; TUint32 index = 0; TUint32 x = 0; TUint32 y = 0; TUint32 startingOffset = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth + aMetricParams->iTestCoordinates.iStartIndexX; TUint32 offset = (aImageEffectDisable->iImageParams.iImageWidth - aMetricParams->iTestCoordinates.iPixelsToGrabX); TUint8 *iR = aImageEffectDisable->iImageData.iRChannel + startingOffset; TUint8 *iG = aImageEffectDisable->iImageData.iGChannel + startingOffset; TUint8 *iB = aImageEffectDisable->iImageData.iBChannel + startingOffset; //TUint8 *oR = aImageEffectEnable->iImageData.iRChannel + startingOffset; //TUint8 *oG = aImageEffectEnable->iImageData.iGChannel + startingOffset; //TUint8 *oB = aImageEffectEnable->iImageData.iBChannel + startingOffset; TUint8 temp = 0; //TUint32 itemp = 0; //TUint32 otemp = 0; for(y=0; y < aMetricParams->iTestCoordinates.iPixelsToGrabY; y++) { for(x=0; x < aMetricParams->iTestCoordinates.iPixelsToGrabX; x++) { if(*iR < 128) { *iR = (*iR) * 2; } else { if(*iR != 128) { *iR = 510 - ((*iR) * 2); } } if(*iG < 128) { *iG = (*iG) * 2; } else { if(*iG != 128) { *iG = 510 - ((*iG) * 2); } } if(*iB < 128) { *iB = (*iB) * 2; } else { if(*iB != 128) { *iB = 510 - ((*iB) * 2); } } /* itemp = ((*iR)+(*iG)+(*iB))/3; if(itemp < 128) { itemp = itemp * 2; } else { itemp = 512 - (itemp * 2); } otemp = ((*oR)+(*oG)+(*oB))/3; Intensity_Im1 = Intensity_Im1 + itemp; Intensity_Im2 = Intensity_Im2 + otemp; */ iR++; iG++; iB++; //oR++; //oG++; //oB++; } iR += offset; iG += offset; iB += offset; //oR += offset; //oG += offset; //oB += offset; } 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 ); //Intensity_Im1 = Intensity_Im1/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY); //Intensity_Im2 = Intensity_Im2/(aMetricParams->iTestCoordinates.iPixelsToGrabX * aMetricParams->iTestCoordinates.iPixelsToGrabY); Intensity_Im1 = (R_Avg_Im1 + G_Avg_Im1 + B_Avg_Im1)/3.255; Intensity_Im2 = (R_Avg_Im2 + G_Avg_Im2 + B_Avg_Im2)/3.255; ALGO_Log_2("Intensity_Im1 = %10f, Intensity_Im2 %10f\n", Intensity_Im1, Intensity_Im2); if( Intensity_Im1 == Intensity_Im2) { return EErrorNone; } else { return EErrorNotValidated; } #endif }
/** * Validation Metric for the Gamma 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 ValidationMetricGammaEffect( const TAlgoImage* aImageEffectDisable, const TAlgoImage* aImageEffectEnable, const TAlgoMetricParams* aMetricParams ) { TUint32 i = 0; TUint32 j = 0; TUint32 index = 0; TUint32 index1 = 0; TReal64 tolerance = 0; TReal64 colonCurrentRImg1 = 0; TReal64 colonCurrentRImg2 = 0; TReal64 colonPreviousImg1 = 0; TReal64 colonPreviousImg2 = 0; TInt32 posDeviationImg1 = 0; TInt32 negDeviationImg1 = 0; TInt32 posDeviationImg2 = 0; TInt32 negDeviationImg2 = 0; TReal64 prevDeviation = 0; TReal64 currDeviation = 0; TUint32 startingOffset = 0; TAlgoParamGamma *paramGamma = (TAlgoParamGamma*)aMetricParams->iParams; 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_2("Gamma Metric : iPrGamma_1 %d, iPrGamma_2 %d\n\n", paramGamma->iPrGamma_1, paramGamma->iPrGamma_2); startingOffset = aMetricParams->iTestCoordinates.iStartIndexY * aImageEffectDisable->iImageParams.iImageWidth + aMetricParams->iTestCoordinates.iStartIndexX; 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]); } index1 = startingOffset; index = index1; for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabX; i=i+50 ) { for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabY; j++) { colonCurrentRImg1 = colonCurrentRImg1 + aImageEffectDisable->iImageData.iRChannel[index]; index = index + aImageEffectDisable->iImageParams.iImageWidth; } colonCurrentRImg1 = colonCurrentRImg1/aMetricParams->iTestCoordinates.iPixelsToGrabY; if (i == 0) { colonPreviousImg1 = colonCurrentRImg1; } currDeviation = (colonCurrentRImg1 - colonPreviousImg1); ALGO_Log_1("currDeviation = %2f \n", currDeviation); if((currDeviation - prevDeviation) > 0) { posDeviationImg1++; //colonPreviousImg1 = colonCurrentRImg1; } if((prevDeviation - currDeviation) > 0) { negDeviationImg1++; //colonPreviousImg1 = colonCurrentRImg1; } prevDeviation = currDeviation; colonPreviousImg1 = colonCurrentRImg1; colonCurrentRImg1 = 0; index1 = index1 + 50; index = index1; } prevDeviation = 0; currDeviation = 0; index1 = startingOffset; index = index1; for( i=0; i<aMetricParams->iTestCoordinates.iPixelsToGrabX; i=i+50 ) { for(j=0; j<aMetricParams->iTestCoordinates.iPixelsToGrabY; j++) { colonCurrentRImg2 = colonCurrentRImg2 + aImageEffectEnable->iImageData.iRChannel[index]; index = index + aImageEffectEnable->iImageParams.iImageWidth; } colonCurrentRImg2 = colonCurrentRImg2/aMetricParams->iTestCoordinates.iPixelsToGrabY; if (i == 0) { colonPreviousImg2 = colonCurrentRImg2; } currDeviation = (colonCurrentRImg2 - colonPreviousImg2); ALGO_Log_1("currDeviation = %2f \n", currDeviation); if((currDeviation - prevDeviation) > 0) { posDeviationImg2++; //colonPreviousImg2 = colonCurrentRImg2; } if((prevDeviation - currDeviation) > 0) { negDeviationImg2++; //colonPreviousImg2 = colonCurrentRImg2; } prevDeviation = currDeviation; colonPreviousImg2 = colonCurrentRImg2; colonCurrentRImg2 = 0; index1 = index1 + 50; index = index1; } ALGO_Log_2("posDeviationImg1 = %2d, negDeviationImg1 = %2d\n", posDeviationImg1, negDeviationImg1); ALGO_Log_2("posDeviationImg2 = %2d, negDeviationImg2 = %2d\n", posDeviationImg2, negDeviationImg2); tolerance = GAMMA_THRESHOLD - aMetricParams->iErrorTolerance.iErrorToleranceR; if(((ABS(negDeviationImg1 - posDeviationImg1)) - (ABS(negDeviationImg2 - posDeviationImg2))) > tolerance) { return EErrorNone; } else { return EErrorNotValidated; } }
/** * The function resizes the input buffer using bilinear interpolation. * * @param aInput [TUint8*] Input Buffer. * @param aOutput [TUint8*] Output Buffer. * @param aInputWidth [TUint32] Width of the input Buffer. * @param aInputHeight [TUint32] Height of the input Buffer. * @param aOutputWidth [TUint32] Width of the output Buffer. * @param aOutputHeight [TUint32] Height of the output Buffer. * * @return [TAlgoError] EErrorNone if the bilinear interpolation is computed successfully. */ TAlgoError ResizeBilinearInterpolation(TUint8* aInput, TUint8* aOutput, TUint32 aInputWidth, TUint32 aInputHeight, TUint32 aOutputWidth, TUint32 aOutputHeight) { TReal64 nXFactor = (TReal64)aInputWidth/(TReal64)aOutputWidth; TReal64 nYFactor = (TReal64)aInputHeight/(TReal64)aOutputHeight; TReal64 fraction_x, fraction_y, one_minus_x, one_minus_y; TInt32 ceil_x, ceil_y, floor_x, floor_y; TUint8 color; TUint8 b1, b2; TUint8 c1, c2, c3, c4; TUint32 x = 0; TUint32 y = 0; TUint32 tmp =0; for ( x = 0; x < aOutputWidth; ++x) { for ( y = 0; y < aOutputHeight; ++y) { // Setup floor_x = (TInt32)(x * nXFactor); floor_y = (TInt32)(y * nYFactor); ceil_x = floor_x + 1; if (ceil_x >= aInputWidth) ceil_x = floor_x; ceil_y = floor_y + 1; if (ceil_y >= aInputHeight) ceil_y = floor_y; fraction_x = x * nXFactor - floor_x; fraction_y = y * nYFactor - floor_y; one_minus_x = 1.0 - fraction_x; one_minus_y = 1.0 - fraction_y; c1 = aInput[(floor_y * aInputWidth) + floor_x]; c2 = aInput[(floor_y * aInputWidth) + ceil_x]; c3 = aInput[(ceil_y * aInputWidth) + floor_x]; c4 = aInput[(ceil_y * aInputWidth) + ceil_x]; b1 = (TUint8)(one_minus_x * c1 + fraction_x * c2); b2 = (TUint8)(one_minus_x * c3 + fraction_x * c4); color = (TUint8)(one_minus_y * (TReal64)(b1) + fraction_y * (TReal64)(b2)); tmp = (TUint32)(one_minus_y * (TReal64)(b1) + fraction_y * (TReal64)(b2)); if(tmp != color) { ALGO_Log_2("\t error color = %d != %d = tmp\n", color, tmp); } aOutput[(y * aOutputWidth) + x] = color; //ALGO_Log_1("\t resise color = %d\n", color); } //ALGO_Log_3("\t\t\t x=%d, y=%d, aOutput[(y * aOutputWidth) + x]=%d\n", x, y, aOutput[(y * aOutputWidth) + x]); //ALGO_Log_4("c1=%d, c2=%d, c3=%d, c4=%d\n", c1, c2, c3, c4); //ALGO_Log_4("one_minus_x=%2.f, c1=%d, fraction_x=%2.f, c2=%d\n", one_minus_x, c1, fraction_x, c2); //ALGO_Log_4("one_minus_x=%2.f, c3=%d, fraction_x=%2.f, c4=%d\n", one_minus_x, c3, fraction_x, c4); //ALGO_Log_4("one_minus_y=%2.f, b1=%d, fraction_y=%2.f, b2=%d\n", one_minus_y, b1, fraction_y, b2); } /* TUint32 i=0; TUint32 j=0; TUint32 x1=0; TUint32 x2=0; TUint32 y1=0; TUint32 y2=0; TUint32 XX1 = 0; TUint32 XX2 = 0; TUint32 YY1 = 0; TUint32 YY2 = 0; TReal64 x = 0; TReal64 y = 0; TReal64 delta_11 = 0; TReal64 delta_12 = 0; TReal64 delta_21 = 0; TReal64 delta_22 = 0; TReal64 fac = 0; TUint32 m = aInputWidth; TUint32 n = aInputHeight; TUint32 aM = aOutputWidth; TUint32 aN = aOutputHeight; for( i=0; i<aM; i++) { for( j=0; j<aN; j++) { x1 = (TInt32)(i*m/aM); x2 = x1 + 1; y1 = (TInt32)(j*n/aN); y2 = y1 + 1; x = ((TReal64)(i/aM))*m; y = ((TReal64)(j/aN))*n; delta_11 = (x2-x)*(y2-y); delta_12 = (x2-x)*(y-y1); delta_21 = (x-x1)*(y2-y); delta_22 = (x-x1)*(y-y1); fac=(x2-x1)*(y2-y1); XX1=MIN_NUM(x1+1,m); XX2=MIN_NUM(x2+1,m); YY1=MIN_NUM(y1+1,n); YY2=MIN_NUM(y2+1,n); //grid_out(i+1,j+1)=(delta_11*grid_in(X1,Y1)+delta_12*grid_in(X1,Y2)+delta_21*grid_in(X2,Y1)+delta_22*grid_in(X2,Y2))/fac; aOutput[i+1,j+1]=(delta_11 * aInput[XX1,YY1]+ delta_12 * aInput[XX1,YY2]+ delta_21 * aInput[XX2,YY1]+ delta_22 * aInput[XX2,YY2])/fac; } } */ return EErrorNone; }
/** * 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; }