test.cpp

这是个人脸识别程序

ScaleRgbImage(RgbImg, RgbImg.width, int(RgbImg.height/3.5), fgVerbose, false);
Compare(RgbImg, "sc_d1_35c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width, int(RgbImg.height/3.5), fgVerbose, true);
Compare(RgbImg, "sc_d1_35cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width/3, RgbImg.height/3, fgVerbose, false);
Compare(RgbImg, "sc_d3_3c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width/3, RgbImg.height/3, fgVerbose, true);
Compare(RgbImg, "sc_d3_3cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, int(RgbImg.width/3.5), RgbImg.height/3, fgVerbose, false);
Compare(RgbImg, "sc_d35_3c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, int(RgbImg.width/3.5), RgbImg.height/3, fgVerbose, true);
Compare(RgbImg, "sc_d35_3cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width * 2, RgbImg.height, fgVerbose, false);
Compare(RgbImg, "sc_u2_1c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width * 2, RgbImg.height, fgVerbose, true);
Compare(RgbImg, "sc_u2_1cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, int(RgbImg.width * 2.5), RgbImg.height, fgVerbose, false);
Compare(RgbImg, "sc_u25_1c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, int(RgbImg.width * 2.5), RgbImg.height, fgVerbose, true);
Compare(RgbImg, "sc_u25_1cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width, RgbImg.height * 2, fgVerbose, false);
Compare(RgbImg, "sc_u1_2c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width, RgbImg.height * 2, fgVerbose, true);
Compare(RgbImg, "sc_u1_2cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width, int(RgbImg.height * 2.5), fgVerbose, false);
Compare(RgbImg, "sc_u1_25c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width, int(RgbImg.height * 2.5), fgVerbose, true);
Compare(RgbImg, "sc_u1_25cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width * 2, RgbImg.height * 2, fgVerbose, false);
Compare(RgbImg, "sc_u2_2c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, RgbImg.width * 2, RgbImg.height * 2, fgVerbose, true);
Compare(RgbImg, "sc_u2_2cb.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, int(RgbImg.width * 2.5), int(RgbImg.height * 2.5), fgVerbose, false);
Compare(RgbImg, "sc_u25_25c.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, int(RgbImg.width * 2.5), int(RgbImg.height * 2.5), fgVerbose, true);
Compare(RgbImg, "sc_u25_25cb.bmp", __LINE__);

// ExtendImage

LoadTestImage(Img);
ExtendImage(Img, 0, 0, 0, 0, fgVerbose);
Compare(Img, "ex_0_0_0_0.bmp", __LINE__);

LoadTestImage(Img);
ExtendImage(Img, 8, 0, 0, 0, fgVerbose);
Compare(Img, "ex_8_0_0_0.bmp", __LINE__);

LoadTestImage(Img);
ExtendImage(Img, 0, 6, 0, 0, fgVerbose);
Compare(Img, "ex_0_6_0_0.bmp", __LINE__);

LoadTestImage(Img);
ExtendImage(Img, 0, 0, 5, 0, fgVerbose);
Compare(Img, "ex_0_0_5_0.bmp", __LINE__);

LoadTestImage(Img);
ExtendImage(Img, 0, 0, 0, 3, fgVerbose);
Compare(Img, "ex_0_0_0_3.bmp", __LINE__);

LoadTestImage(Img);
ExtendImage(Img, 8, 7, 0, 0, fgVerbose);
Compare(Img, "ex_8_7_0_0.bmp", __LINE__);

LoadTestImage(Img);
ExtendImage(Img, 0, 0, 7, 6, fgVerbose);
Compare(Img, "ex_0_0_7_6.bmp", __LINE__);

LoadTestImage(Img);
ExtendImage(Img, 1, 2, 3, 4, fgVerbose);
Compare(Img, "ex_1_2_3_4.bmp", __LINE__);

// ReduceImage

LoadTestImage(Img);
ReduceImage(Img, 1, IM_AVERAGE_ALL, fgVerbose);
Compare(Img, "re_1.bmp", __LINE__);

LoadTestImage(Img);
ReduceImageAssign(Img1, Img, 1, IM_AVERAGE_ALL, fgVerbose);
Compare(Img, "imtest.bmp", __LINE__);		// make sure original image hasn't changed
Compare(Img1, "re_1.bmp", __LINE__);

LoadTestImage(Img);
ReduceImage(Img, 2, IM_AVERAGE_ALL, fgVerbose);
Compare(Img, "re_2.bmp", __LINE__);

LoadTestImage(Img);
ReduceImageAssign(Img1, Img, 2, IM_AVERAGE_ALL, fgVerbose);
Compare(Img, "imtest.bmp", __LINE__);
Compare(Img1, "re_2.bmp", __LINE__);

LoadTestImage(Img);
ReduceImage(Img, 3, IM_AVERAGE_ALL, fgVerbose);
Compare(Img, "re_3.bmp", __LINE__);

LoadTestImage(Img);
ReduceImageAssign(Img1, Img, 3, IM_AVERAGE_ALL, fgVerbose); 
Compare(Img, "imtest.bmp", __LINE__);
Compare(Img1, "re_3.bmp", __LINE__);

LoadTestImage(Img);
ReduceImage(Img, 8, IM_AVERAGE_ALL, fgVerbose);
Compare(Img, "re_8.bmp", __LINE__);

LoadTestImage(Img);
ReduceImageAssign(Img1, Img, 8, IM_AVERAGE_ALL, fgVerbose); 
Compare(Img, "imtest.bmp", __LINE__);
Compare(Img1, "re_8.bmp", __LINE__);

// ExtractImage

// test some null transformations: no rescale and no rotations
LoadTestImage(Img);
ExtractImage(Img, Img.width, Img.height, Img.width/2, Img.height/2, 1.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "imtest.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, Img.width, Img.height, Img.width/2, Img.height/2, 1.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
CompareImageToFile(Img, "ref/imtest.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, Img.width, Img.height, Img.width/2, Img.height/2, 1.0, 0.0, fgVerbose, IM_BILINEAR, IM_CLIP);
CompareImageToFile(Img, "ref/imtest.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, Img.width, Img.height, Img.width/2, Img.height/2, 1.0, 0.0, fgVerbose, IM_BILINEAR, IM_EXTEND);
CompareImageToFile(Img, "ref/imtest.bmp", __LINE__);

// TODO 360 degress rotation (i.e. a null transform) produces image with some black pixels at border
#if 0
ExtractImage(Img, Img.width, Img.height, Img.width/2, Img.height/2, 1.0, 2 * PI, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
CompareImageToFile(Img, "ref/imtest.bmp", __LINE__);
#endif

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e40_26_20_13_1_0c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_0.bmp", __LINE__);

// TODO Following image has black pixels at some borders
// For now I'm using a reference that has the same problem
LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 0.0, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e40_26_20_13_1_0bc.bmp", __LINE__);

// TODO Following image has black pixels at some borders
LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 0.0, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_0b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 1.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e30_20_20_26_1_0c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 1.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e30_20_20_26_1_0.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 1.0, 0.0, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e30_20_20_26_1_0bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 1.0, 0.0, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e30_20_20_26_1_0b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 0.5, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e30_20_20_26_05_0c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 0.5, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e30_20_20_26_05_0.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 0.5, 0.0, fgVerbose, IM_BILINEAR, IM_CLIP);
//Compare(Img, "e30_20_20_26_05_0bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 0.5, 0.0, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e30_20_20_26_05_0b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 2.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e30_20_20_26_20_0c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 2.0, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e30_20_20_26_20_0.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 2.0, 0.0, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e30_20_20_26_20_0bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 20, 13, 2.0, 0.0, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e30_20_20_26_20_0b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 24, 18, 0.5, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e30_20_24_28_05_0c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 24, 18, 0.5, 0.0, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e30_20_24_28_05_0.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 24, 18, 0.5, 0.0, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e30_20_24_28_05_0bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 30, 20, 24, 18, 0.5, 0.0, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e30_20_24_28_05_0b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/4, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e40_26_20_13_1_45c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/4, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_45.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/4, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e40_26_20_13_1_45bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/4, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_45b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, -PI/4, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e40_26_20_13_1_-45c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, -PI/4, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_-45.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, -PI/4, fgVerbose, IM_BILINEAR, IM_CLIP);
#if 1
Compare(Img, "e40_26_20_13_1_-45bc.bmp", __LINE__);
#endif

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, -PI/4, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_-45b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/2, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e40_26_20_13_1_90c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/2, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_90.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/2, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e40_26_20_13_1_90bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI/2, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_90b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e40_26_20_13_1_180c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_180.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e40_26_20_13_1_180bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, PI, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_180b.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 2*PI, fgVerbose, IM_NEAREST_PIXEL, IM_CLIP);
Compare(Img, "e40_26_20_13_1_360c.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 2*PI, fgVerbose, IM_NEAREST_PIXEL, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_360.bmp", __LINE__);

// TODO Following image has black pixels at some borders
LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 2*PI, fgVerbose, IM_BILINEAR, IM_CLIP);
Compare(Img, "e40_26_20_13_1_360bc.bmp", __LINE__);

LoadTestImage(Img);
ExtractImage(Img, 40, 26, 20, 13, 1.0, 2*PI, fgVerbose, IM_BILINEAR, IM_EXTEND);
Compare(Img, "e40_26_20_13_1_360b.bmp", __LINE__);

// misc

LoadTestImage(Img);
DrawVerticalLine(Img, 12, fgVerbose);
Compare(Img, "line_v_12.bmp", __LINE__);

LoadTestImage(Img);
DrawHorizontalLine(Img, 10, fgVerbose);
Compare(Img, "line_h_10.bmp", __LINE__);

LoadTestImage(RgbImg);
DrawRectInBmp(RgbImg, 4, 6, 5, 9, C_BLUE);
Compare(RgbImg, "rect4_6_5_9f.bmp", __LINE__);

LoadTestImage(RgbImg);
DrawRectInBmp(RgbImg, 4, 6, 5, 9, C_YELLOW);
Compare(RgbImg, "rect4_6_5_9t.bmp", __LINE__);

LoadTestImage(RgbImg);
ScaleRgbImage(RgbImg, 100, 50, false, true);
RgbPrintf(RgbImg, 20, 5, C_YELLOW, 180, "Test %d", 1);	// coords in shape coords
WriteBmp(RgbImg, "out/printf1.bmp", false);
Compare(RgbImg, "printf1.bmp", __LINE__);

//-- equalization tests -------------------

LoadTestImage(Img);
EqualizeImage(Img);
Compare(Img, "eq.bmp", __LINE__);

LoadTestImage(Img);
EqualizeMirrorImage(Img);	// mirror and equalize
Compare(Img, "eq_mirror.bmp", __LINE__);

LoadTestImage(Img);
EqualizeImage(Img, IM_QUICK_EQUALIZE);
Compare(Img, "eq_quick.bmp", __LINE__);

LoadTestImage(RgbImg);
EqualizeRgbImage(RgbImg);
Compare(RgbImg, "eq_rgb.bmp", __LINE__);

LoadTestImage(RgbImg);
WriteBmp(RgbImg, "out/ref.bmp", false);
QuickEqualizeRgbImage(RgbImg);
Compare(RgbImg, "eq_quick_rgb.bmp", __LINE__);

// test EqualizeImg1 with mask that covers entire image and no lighting correction - should match EqualizeImg

sLoadImage(Img, "ref/imtest.bmp");
int nxMin = xImgToShape(0, Img);
int nxMax = xImgToShape(Img.width, Img);
int nyMin = yImgToShape(0, Img);
int nyMax = yImgToShape(Img.height, Img);
lprintf("Expect two messages \"EqualizeAndCorrectImage fCorrectLighting=true is not reliable\"\n");
EqualizeAndCorrectImage(Img, nxMin, nxMax, nyMin, nyMax, QUIET);
Compare(Img, "eq.bmp", __LINE__);

#if 0
// now with lighting correction
sLoadImage(Img, "ref/imtest.bmp");
EqualizeAndCorrectImage(Img, nxMin, nxMax, nyMin, nyMax, QUIET, IM_CORRECT_LIGHTING);
Compare(Img, "eq_correct.bmp", __LINE__);
#endif

// test EqualizeImg1 with smaller mask

sLoadImage(Img, "ref/imtest.bmp");
const double BShapeData[] = { -20, -7, 4, 7 };
SHAPE BShape(BShapeData, 2, 2);
GetEqualizationMask(nxMin, nxMax, nyMin, nyMax, BShape, Img, 0.25);

ConvertGrayImageToRgb(RgbImg, Img);
DrawRectInBmp(RgbImg, xShapeToImg(nxMin, Img), yShapeToImg(nyMin, Img), nxMax - nxMin, nyMax - nyMin, C_YELLOW);
Compare(RgbImg, "eq_showmask.bmp", __LINE__);

sLoadImage(Img, "ref/imtest.bmp");
EqualizeAndCorrectImage(Img, nxMin, nxMax, nyMin, nyMax, QUIET);
Compare(Img, "eq_smask.bmp", __LINE__);

sLoadImage(Img, "ref/imtest.bmp");
EqualizeAndCorrectImage(Img, nxMin, nxMax, nyMin, nyMax, QUIET);
Compare(Img, "eq_smaskCorrect.bmp", __LINE__);

// demonstrate DumpBmpHeader

if (fgVerbose)
	DumpBmpHeader("ref/imtest.bmp");

if (ngWarnings != CONF_nExpectedWarnings)
	TestFail("Unexpected number %d of warnings\n", ngWarnings, __LINE__);

if (ngFails == 0)
	lprintf("All %d tests passed, images in out/*.bmp\n", ngTests);
else
	lprintf("%d of %d tests failed, images in out/*.bmp and compare/*.bmp\n", ngFails, ngTests);

return 0;
}