flog.cpp

这是个人脸识别程序

// $util\flog.cpp 1.5 milbo$ filter ms logs and print summary
// Warning: this is raw research code -- expect it to be quite messy.
// milbo petaluma aug 05
//-----------------------------------------------------------------------------
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// A copy of the GNU General Public License is available at
// http://www.r-project.org/Licenses/
//-----------------------------------------------------------------------------

#include "all.hpp"

#define BASE_SHAPE_LEV						CONF_nLevs
#define NLEVS	(CONF_nLevs+1)				// +1 for storing StartShape stats like any other level

static int  ngLine = 0;						// line number in log file
#define NLINE 5000							// big enough for extended lines from ms
static char sgLine[NLINE];					// current line in log file

static char sgImageDir[SLEN];				// directory used for images
static char sgFname[SLEN];					// current filename

static int igPrefix;
static char cgPrefix0, cgPrefix1;

static int ngMaxLev = -100, ngMinLev = 100, igLev = 100;

static int 		ngDone[2];					// [2] for two prefixes
static int 		ngFilePrefixChange[2];		// index when we changed from one file prefix to another
static char		cgFilePrefix[2];

static double 	gFit[NLEVS][2];		// average fit
static double	gVal0[CONF_nMaxMatDim];		// specific values for Fit for igPrefix==0
static double	gVal1[CONF_nMaxMatDim];		// specific values for Fit for igPrefix==1
static int 		igVal0, igVal1;				// reference into gFitVal
static int 		ngWorseVal, ngBetterVal;	// number of pass 2 Fits Worse than (same as) pass 1

static double 	gLEyeFit[NLEVS][2];
static double	gLEyeVal0[CONF_nMaxMatDim];			// specific values for Fit for igPrefix==0
static double	gLEyeVal1[CONF_nMaxMatDim];			// specific values for Fit for igPrefix==1
static int 		igLEyeVal0, igLEyeVal1;				// reference into gLEyeVal
static int 		ngWorseLEyeVal, ngBetterLEyeVal;	// number of pass 2 Fits Worse than (same as) pass 1

static double 	gREyeFit[NLEVS][2];
static double	gREyeVal0[CONF_nMaxMatDim];			// specific values for Fit for igPrefix==0
static double	gREyeVal1[CONF_nMaxMatDim];			// specific values for Fit for igPrefix==1
static int 		igREyeVal0, igREyeVal1;				// reference into gREyeVal
static int 		ngWorseREyeVal, ngBetterREyeVal;	// number of pass 2 Fits Worse than (same as) pass 1

static double 	gMouthFit[NLEVS][2];
static double	gMouthVal0[CONF_nMaxMatDim];		// specific values for Fit for igPrefix==0
static double	gMouthVal1[CONF_nMaxMatDim];		// specific values for Fit for igPrefix==1
static int 		igMouthVal0, igMouthVal1;			// reference into gFitMouthVal
static int 		ngWorseMouthVal, ngBetterMouthVal;	// number of pass 2 Fits Worse than (same as) pass 1

static double 	gPointFit[NLEVS][2];
static double	gPointVal0[CONF_nMaxMatDim];		// specific values for Fit for igPrefix==0
static double	gPointVal1[CONF_nMaxMatDim];		// specific values for Fit for igPrefix==1
static int 		igPointVal0, igPointVal1;			// reference into gPointVal
static int 		ngWorsePointVal, ngBetterPointVal;	// number of pass 2 Fits Worse than (same as) pass 1
static int		igPoint = -1;

static int 		ngFit[NLEVS][2];
static int 		ngLEyeFit[NLEVS][2];
static int 		ngREyeFit[NLEVS][2];
static int 		ngMouthFit[NLEVS][2];
static int 		ngPointFit[NLEVS][2];

static double 	gMax[NLEVS][2];
static int 		ngMax[NLEVS][2];
static double	gTime[2];

static bool 	fgIgnore = false;

//-----------------------------------------------------------------------------
static CheckThatAllNsMatch (void)
{
int N = ngFit[0][0];

#if 1	// it's no longer an error if we don't match at all levels
for (int iLev = ngMinLev; iLev >= ngMinLev; iLev--)
#else
for (int iLev = ngMaxLev; iLev >= ngMinLev; iLev--)
#endif
	{
	if (ngFit[iLev][0] != N)
		lprintf("Err: Fit N[iLev %d][0] %d != N[iLev 0][0] %d\n", iLev, ngFit[iLev][0], N);

	if (ngLEyeFit[0][0] && ngLEyeFit[iLev][0] != N)
		lprintf("Err: LEyeFit N[%d][0] %d != %d\n", iLev, ngLEyeFit[iLev][0], N);

	if (ngREyeFit[0][0] && ngREyeFit[iLev][0] != N)
		lprintf("Err: REyeFit N[%d][0] %d != %d\n", iLev, ngREyeFit[iLev][0], N);

	if (ngMouthFit[0][0] && ngMouthFit[iLev][0] != N)
		lprintf("Err: MouthFit N[%d][0] %d != %d\n", iLev, ngMouthFit[iLev][0], N);

	if (ngPointFit[0][0] && ngPointFit[iLev][0] != N)
		lprintf("Err: PointFit N[%d][0] %d != %d\n", iLev, ngPointFit[iLev][0], N);

	if (cgPrefix1 && ngFit[iLev][1] != N)
		lprintf("Err: Fit N[iLev %d][Prefix 1] %d != ngFit[iLev 0][Prefix 0] %d\n", iLev, ngFit[iLev][1], N);

	if (ngMax[iLev][0] != N)
		lprintf("Err: nMax N[%d][0] %d != %d\n", iLev, ngMax[iLev][0], N);

	if (cgPrefix1 && ngMax[iLev][1] != N)
		lprintf("Err: nMax N[%d][1] %d != %d\n", iLev, ngMax[iLev][1], N);
	}
}

//-----------------------------------------------------------------------------
static void CheckSameNbrResults (void)
{
if (cgPrefix1)
	{
	if (igVal0 != igVal1)
		Err("Different number of Fit results for prefix %c (%d) and prefix %c (%d)",
			cgPrefix0, igVal0, cgPrefix1, igVal1);

	if (igLEyeVal0 != igLEyeVal1)
		Err("Different number of LEyeFit results for prefix %c (%d) and prefix %c (%d)",
			cgPrefix0, igLEyeVal0, cgPrefix1, igLEyeVal1);

	if (igREyeVal0 != igREyeVal1)
		Err("Different number of REyeFit results for prefix %c (%d) and prefix %c (%d)",
			cgPrefix0, igREyeVal0, cgPrefix1, igREyeVal1);

	if (igMouthVal0 != igMouthVal1)
		Err("Different number of MouthFit results for prefix %c (%d) and prefix %c (%d)",
			cgPrefix0, igMouthVal0, cgPrefix1, igMouthVal1);

	if (igPointVal0 != igPointVal1)
		Err("Different number of PointFit results for prefix %c (%d) and prefix %c (%d)",
			cgPrefix0, igPointVal0, cgPrefix1, igPointVal1);

	if (ngDone[0] != igVal0)
		lprintf("Err: ngDone[0] %d != %d\n", ngDone[0], igVal0);

	if (ngDone[1] != igVal1)
		lprintf("Err: ngDone[1] %d != %d\n", ngDone[1], igVal1);

	if (ngFilePrefixChange[0] != ngFilePrefixChange[0])	// different number of XM2VTS and BioId files in testset A and testset B?
		lprintf("Err: ngFilePrefixChange[0] %d != %d\n", ngFilePrefixChange[0], ngFilePrefixChange[1]);
	}
if (igLEyeVal0 && igLEyeVal0 != igVal0)
	Err("Different number of LEyeFit results %d and Fit results %d\n", igLEyeVal0, igVal0);

if (igREyeVal0 && igREyeVal0 != igVal0)
	Err("Different number of REyeFit results %d and Fit results %d\n", igREyeVal0, igVal0);

if (igMouthVal0 && igMouthVal0 != igVal0)
	Err("Different number of MouthFit results %d and Fit results %d\n", igMouthVal0, igVal0);

if (igPointVal0 && igPointVal0 != igVal0)
	Err("Different number of PointFit results %d and Fit results %d\n", igPointVal0, igVal0);
}

//-----------------------------------------------------------------------------
static inline double Sqrt (double x)
{
if (!fIeeeNormal(x))
	SysErr("Sqrt: %g not IEEE normal", x);
if (x < 0)
	SysErr("Sqrt: %g less than zero", x);
return sqrt(x);
}

//-----------------------------------------------------------------------------
//
// N=25          A        SDev       B        SDev     PairedT  TProb  ChangeAtoB  BetterB WorseB  Base
// Fit          4.73      0.90      4.71      0.94      0.10    0.393     -0.5%      52%    24%    4.8
// Max         15.69               15.59                                  -0.6%
// LEyeFit      3.76      1.58      3.76      1.58     -0.00    0.395      0.1%      44%    32%    5.2
// REyeFit      3.76      1.58      3.76      1.58     -0.00    0.395      0.1%      44%    32%    5.1
// MouthFit     3.85      1.15      3.82      1.21      0.08    0.393     -0.8%      36%    44%    4.9
// Point57      1.85      1.15      0.82      1.21      0.08    0.393     -0.8%      36%    44%    2.3
// Time         0.30                0.27                                  -8.5%

static void ShowSummaryTotals (char sHeader[], int iStart, int iEnd, bool fFullRange)
{
char sPrefix[SLEN];
if (fFullRange)
	sPrefix[0] = 0;
else
	sprintf(sPrefix, "%s", sHeader);

double Fit0, Dev0;
CheckSameNbrResults();

int n = iEnd-iStart;
MeanAndVariance(Fit0, Dev0, &gVal0[iStart], n);
Dev0 = Sqrt(Dev0);
double Max0 = gMax[0][0] / n;

double StudentsT, TProb;
double Fit1 = 0, Dev1 = 0, Max1 = 0;
if (n)
	{
	MeanAndVariance(Fit1, Dev1, &gVal1[iStart], n);
	Dev1 = Sqrt(Dev1);
	StudentsTPairedSampleTest(StudentsT, TProb, &gVal0[iStart], &gVal1[iStart], n);
	Max1 = gMax[0][1] / ngFit[0][1];
	}
double Time0 = 0;
if (ngDone[0])
	Time0 = gTime[0] / ngDone[0];
double Time1 = 0;
if (ngDone[1])
	Time1 = gTime[1] / ngDone[1];

lprintf("\n%-6.6sN=%2.2d%s  %c         SDev      %c         %s  ",
	sHeader,
	n,
	(n > 99? "": " "),
	(cgPrefix0? cgPrefix0: ' '),
	(cgPrefix1? cgPrefix1: ' '),
	(cgPrefix1? "SDev": "    "));
if (ngFit[0][1])
	lprintf("   PairedT  TProb  Change%cto%c", (cgPrefix1? cgPrefix1: '1'), (cgPrefix0? cgPrefix0: '0'));
if (fFullRange && ngFit[0][1])
	lprintf("  Better%c Worse%c", (cgPrefix0? cgPrefix0: '0'), (cgPrefix1? cgPrefix1: '1'));
if (fFullRange)
	lprintf("   Base  ChangeBaseTo%c", (cgPrefix0? cgPrefix0: '0'));
lprintf("\n");

lprintf("%sFit      %8.3f  %8.3f  ", sPrefix, Fit0, Dev0);
if (Fit1 != 0) lprintf("%8.3f  %8.3f  ", Fit1, Dev1); else lprintf("                  ");
if (ngFit[0][1])
	{
	lprintf("%8.2f %8.3f  ", StudentsT, TProb);
	lprintf("  %5.1f%%", 100 * (Fit1 - Fit0)/Fit0);
	}
if (fFullRange)
	{
	if (ngFit[0][1])
		lprintf("    %4d%%  %4d%% ", (100 * ngBetterVal) / igVal0, (100 * ngWorseVal) / igVal0);
	lprintf(" %8.3f  %5.1f%%", gFit[BASE_SHAPE_LEV][0]/ngFit[0][0],
			100 * (gFit[BASE_SHAPE_LEV][0] - gFit[0][0]) / gFit[0][0]);
	}
lprintf("\n");

if (ngLEyeFit[0][0])
	{
	MeanAndVariance(Fit0, Dev0, &gLEyeVal0[iStart], n);
	Dev0 = Sqrt(Dev0);
	Fit1 = 0, Dev1 = 0;
	if (n)
		{
		MeanAndVariance(Fit1, Dev1, &gLEyeVal1[iStart], n);
		Dev1 = Sqrt(Dev1);
		StudentsTPairedSampleTest(StudentsT, TProb, &gLEyeVal0[iStart], &gLEyeVal1[iStart], n);
		}
	lprintf("%sLEyeFit  %8.3f  %8.3f  ", sPrefix, Fit0, Dev0);
	if (Fit1 != 0) lprintf("%8.3f  %8.3f  ", Fit1, Dev1);	else lprintf("                  ");
	if (n && Fit0 != 0 && ngLEyeFit[0][1])
		{
		lprintf("%8.2f  %7.3f  ", StudentsT, TProb);
		lprintf("  %5.1f%%", 100 * (Fit1 - Fit0)/Fit0);
		}
	if (fFullRange)
		{
		if (ngLEyeFit[0][1])
			lprintf("    %4d%%  %4d%% ", (100 * ngBetterLEyeVal) / igLEyeVal0, (100 * ngWorseLEyeVal) / igLEyeVal0);

		lprintf(" %8.3f  %5.1f%%", gLEyeFit[BASE_SHAPE_LEV][0] / ngLEyeFit[BASE_SHAPE_LEV][0],
				100 * (gLEyeFit[BASE_SHAPE_LEV][0] - gLEyeFit[0][0]) / gLEyeFit[0][0]);
		}
	lprintf("\n");
	}
if (ngREyeFit[0][0])
	{
	MeanAndVariance(Fit0, Dev0, &gREyeVal0[iStart], n);
	Dev0 = Sqrt(Dev0);
	Fit1 = 0, Dev1 = 0;
	if (n)
		{
		MeanAndVariance(Fit1, Dev1, &gREyeVal1[iStart], n);
		Dev1 = Sqrt(Dev1);
		StudentsTPairedSampleTest(StudentsT, TProb, &gREyeVal0[iStart], &gREyeVal1[iStart], n);
		}
	lprintf("%sREyeFit  %8.3f  %8.3f  ", sPrefix, Fit0, Dev0);
	if (Fit1 != 0) lprintf("%8.3f  %8.3f  ", Fit1, Dev1);	else lprintf("                  ");
	if (n && Fit0 != 0&& ngREyeFit[0][1])
		{
		lprintf("%8.2f  %7.3f  ", StudentsT, TProb);
		lprintf("  %5.1f%%", 100 * (Fit1 - Fit0)/Fit0);
		}
	if (fFullRange)
		{
		if (ngREyeFit[0][1])
			lprintf("    %4d%%  %4d%% ", (100 * ngBetterREyeVal) / igREyeVal0, (100 * ngWorseREyeVal) / igREyeVal0);
		lprintf(" %8.3f  %5.1f%%", gREyeFit[BASE_SHAPE_LEV][0] / ngREyeFit[BASE_SHAPE_LEV][0],
				100 * (gREyeFit[BASE_SHAPE_LEV][0] - gREyeFit[0][0]) / gREyeFit[0][0]);
		}
	lprintf("\n");
	}
if (ngMouthFit[0][0])
	{
	MeanAndVariance(Fit0, Dev0, &gMouthVal0[iStart], n);
	Dev0 = Sqrt(Dev0);
	Fit1 = 0, Dev1 = 0;
	if (n)
		{
		MeanAndVariance(Fit1, Dev1, &gMouthVal1[iStart], n);
		Dev1 = Sqrt(Dev1);
		StudentsTPairedSampleTest(StudentsT, TProb, &gMouthVal0[iStart], &gMouthVal1[iStart], n);
		}
	lprintf("%sMouthFit %8.3f  %8.3f  ", sPrefix, Fit0, Dev0);
	if (Fit1 != 0) lprintf("%8.3f  %8.3f  ", Fit1, Dev1);	else lprintf("                  ");
	if (n && Fit0 != 0 && ngMouthFit[0][1])
		{
		lprintf("%8.2f  %7.3f ", StudentsT, TProb);
		lprintf("   %5.1f%%", 100 * (Fit1 - Fit0)/Fit0);
		}
	if (fFullRange)
		{
		if (ngMouthFit[0][1])
			lprintf("    %4d%%  %4d%% ", (100 * ngBetterMouthVal) / igMouthVal0, (100 * ngWorseMouthVal) / igMouthVal0);
		lprintf(" %8.3f  %5.1f%%", gMouthFit[BASE_SHAPE_LEV][0] / ngMouthFit[BASE_SHAPE_LEV][0],
				100 * (gMouthFit[BASE_SHAPE_LEV][0] - gMouthFit[0][0]) / gMouthFit[0][0]);
		}
	lprintf("\n");
	}
if (fFullRange)
	{
	if (ngPointFit[0][0])
		{
		MeanAndVariance(Fit0, Dev0, &gPointVal0[iStart], n);
		Dev0 = Sqrt(Dev0);
		Fit1 = 0, Dev1 = 0;
		if (n)
			{
			MeanAndVariance(Fit1, Dev1, &gPointVal1[iStart], n);
			Dev1 = Sqrt(Dev1);
			StudentsTPairedSampleTest(StudentsT, TProb, &gPointVal0[iStart], &gPointVal1[iStart], n);
			}
		lprintf("PointFit%-2d%7.3f  %8.3f  ", igPoint, Fit0, Dev0);
		if (Fit1 != 0) lprintf("%8.3f  %8.3f  ", Fit1, Dev1);	else lprintf("                  ");
		if (n && Fit0 != 0 && ngPointFit[0][1])
			{
			lprintf("%8.2f  %7.3f  ", StudentsT, TProb);
			lprintf("  %5.1f%%", 100 * (Fit1 - Fit0)/Fit0);
			}
		if (ngPointFit[0][1])
			lprintf("    %4d%%  %4d%% ", (100 * ngBetterPointVal) / igPointVal0, (100 * ngWorsePointVal) / igPointVal0);
		lprintf(" %8.3f  %5.1f%%", gPointFit[BASE_SHAPE_LEV][0] / ngPointFit[BASE_SHAPE_LEV][0],
				100 * (gPointFit[BASE_SHAPE_LEV][0] - gPointFit[0][0]) / gPointFit[0][0]);
		lprintf("\n");
		}
	lprintf("Max      %8.3f            ", Max0);			// we only keep the max value for the entire range so this has to be ifed by fFullRange
	if (Max1 != 0)	lprintf("%8.3f  ", Max1); else lprintf("        ");
	if (cgPrefix1 && Max0 != 0)
		lprintf("                               %5.1f%%", 100 * (Max1 - Max0)/Max0);
	lprintf("\n");

	lprintf("[Time    %8.2f            ", Time0);
	if (Time1 != 0)	lprintf("%8.2f         ", Time1); else lprintf("        ");
	if (cgPrefix1 && Time0 != 0)
		lprintf("                       %6.1f%%", 100 * (Time1 - Time0)/Time0);
	lprintf("]\n");
	}
}

//-----------------------------------------------------------------------------
static void ShowFullTotals (void)
{
SysErr("ShowFullTotals not yet implemented");
}

//-----------------------------------------------------------------------------
static void ShowTotals (bool fFull)
{
if (fFull)
	ShowFullTotals();
else
	{
	if (ngFit[0][1] && ngFit[0][1] != ngFit[0][0])
		SysErr("ngFit[0][1] %d != ngFit[0][0] %d", ngFit[0][1], ngFit[0][0]);
	if (ngLEyeFit[0][0])
		{
		ASSERT(ngFit[0][0] == ngLEyeFit[0][0]);
		ASSERT(ngFit[0][1] == ngLEyeFit[0][1]);
		}
	if (ngREyeFit[0][0])
		{
		ASSERT(ngFit[0][0] == ngREyeFit[0][0]);
		ASSERT(ngFit[0][1] == ngREyeFit[0][1]);
		}
	if (ngMouthFit[0][0])
		{
		ASSERT(ngFit[0][0] == ngMouthFit[0][0]);
		ASSERT(ngFit[0][1] == ngMouthFit[0][1]);
		}
	if (ngPointFit[0][0])
		{
		ASSERT(ngFit[0][0] == ngPointFit[0][0]);
		ASSERT(ngFit[0][1] == ngPointFit[0][1]);
		}
	if (ngFilePrefixChange[0] > 0)
		{
		char sHeader[SLEN];
		sprintf(sHeader, "%c", cgFilePrefix[0]);
		ShowSummaryTotals(sHeader, 0, ngFilePrefixChange[0], false);
		sprintf(sHeader, "%c", cgFilePrefix[1]);
		ShowSummaryTotals(sHeader, ngFilePrefixChange[0], ngFit[0][0], false);
		}
	ShowSummaryTotals("ALL", 0, ngFit[0][0], true);
	}
}

//-----------------------------------------------------------------------------
static void SetPrefix (char s[])
{
char c = s[0];

if (c == 0)
	Err("Line %d: Zero length string passed to SetPrefix\n%s", ngLine, sgLine);

if (c == cgPrefix0)
	{
	if (igPrefix == 1)	// going from 1 back to 0?
		CheckSameNbrResults();
	igPrefix = 0;
	}
else if (c == cgPrefix1)
	igPrefix = 1;
else if (cgPrefix0 == 0)
	{
	cgPrefix0 = c;
	igPrefix = 0;
	}
else if (cgPrefix1 == 0)
	{
	cgPrefix1 = c;
	igPrefix = 1;
	}
else
	lprintf("Line %d: ignored unknown prefix (prefixes are %c %c) %s", ngLine, cgPrefix0, cgPrefix1, sgLine);
}

//-----------------------------------------------------------------------------
void InitGlobals (void)
{
igPrefix = cgPrefix0 = cgPrefix1 = 0;