tmt.cpp

这是个人脸识别程序

			Sleep(250);	// sleep 250 ms
			if (_kbhit())
				{
				lprintf("restarted\n");
				break;
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// replace %s with sTestName or %S with short sTestName

static char *sReplaceS (const char sTest[], 		// in
						const char sTestName[])		// in
{
static char sTest1[LSLEN];

char *pDest = strstr(sTest, "%S");
if (pDest)	// %S is in sTest
	{
	// replace %S with %s, results in sTest2
	char sTest2[LSLEN]; strcpy(sTest2, sTest);
	pDest = strstr(sTest2, "%S"); *(pDest+1) = 's';

	// truncate sTestName at -, results in sTestName1
	char sTestName1[LSLEN]; strcpy(sTestName1, sTestName);
	pDest = strstr(sTestName1+1, "-");	//+1 to ignore possible leading minus sign
	if (pDest == NULL)
		MyErr("%%S specified but can't find '-' in %s", sTestName);
	*pDest = 0;

	sprintf(sTest1, sTest2, sTestName1);
	}
else
	sprintf(sTest1, sTest, sTestName);	// change %s (if it exists) to sTestName

return sTest1;
}

//-----------------------------------------------------------------------------
static void RunMs (bool fRun, const char sTest[], char cFileType, bool fUseMirroredFiles,
					const char sMsPParam[], int nFilesPerTest, int nRand, const char sTestName[])
{
PossiblyPause();

char *sFileSpec;
switch (cFileType)
	{
	case 'a': sFileSpec = "-p \" a%s.*_[15]\"";	break;	// %s will be the mirror string
	case 'B': sFileSpec = "-p \" B%s\""; 		break;
	case 'm': sFileSpec = "-p \" m%s\""; 		break;
	}
char sFileSpec1[LSLEN]; sprintf(sFileSpec1, sFileSpec, (fUseMirroredFiles? "": "[^r]"));

char sShortMsParam[LSLEN]; sprintf(sShortMsParam, "%2.2s", (sMsPParam[0]? sMsPParam: "00"));

char s[LSLEN];
sprintf(s, "%s %s %s %s -ni %d -nr %d -s t%s-%s%s",
				sReplaceS(sTest, sTestName),
				sFileSpec1,
				(sMsPParam[0]? "-P":""),
				sMsPParam,
				nFilesPerTest,
				nRand,
				sShortMsParam,				// -s starts here: test file specifier prefixes the test name
				sTestName,					//
	 			(USE_PREFIX_IN_MODEL_NAME? "": gTab.sPrefix));

CheckCmdParams(fRun, s, false);

System(fRun, 0, s);

#if LOG_ERRS
// Search for errors and msgs in the ms.log file and append them to the tmt err file
// iRetCodeHandler is 2 below because egrep returns 1 if it didn't find any strings

System(fRun, 2, "@egrep -i \"MyErr|Warn|Msg\" ms.log >>%s", ERR_FILE);
#endif
}

//-----------------------------------------------------------------------------
static RunRefTest (bool fRun)
{
if (gTab.sRefTest[0])
	{
	Separator();
	lprintf("TEST: --REF\n");
	if (gTab.fAr)
		RunMs(fRun, gTab.sRefTest, 'a', gTab.fUseMirroredFiles, gTab.sMsPParam, gTab.nFilesPerTest, gTab.nRand, "--REF");
	if (gTab.fBioId)
		RunMs(fRun, gTab.sRefTest, 'B', gTab.fUseMirroredFiles, gTab.sMsPParam, gTab.nFilesPerTest, gTab.nRand, "--REF");
	if (gTab.fXm2vts)
		RunMs(fRun, gTab.sRefTest, 'm', gTab.fUseMirroredFiles, gTab.sMsPParam, gTab.nFilesPerTest, gTab.nRand, "--REF");
	}
}

//-----------------------------------------------------------------------------
static void Usage (void)
{
lprintf(
	"Usage: tmt [-ar]\n\n"
	"  -a append to log file\n"
	"  -r to run the tests (else just shows what tests will run)\n\n");

lprintf("This is tmt version 1.5\n");

Shutdown();
exit(-1);
}

//-----------------------------------------------------------------------------
static WriteSemaFile (void)
{
FILE *pSemaFile = fopen(SEMA_FILE, "w");
if (pSemaFile == NULL)
	Err("Can't open %s for writing", SEMA_FILE);
fclose(pSemaFile);
}

//-----------------------------------------------------------------------------
int __cdecl main (int argc, char *argv[])
{
bool fAppendToLog = false;
clock_t StartTime = clock();
char sElapsedTime[LSLEN];

while (--argc > 0 && (*++argv)[0] == '-')
	{
	lprintf("-%c ", *(*argv + 1));
	switch (*(*argv + 1))
		{
		case 'a':
			fAppendToLog = true;
			break;
		case 'r':
			fgRun = true;
			break;
		default:
			lprintf("\nBad flag -%c\n\n", *(*argv + 1));
			Usage();
			break;
		}
	}
Init(VERBOSE, fAppendToLog, "tmt.log");
signal(SIGINT, IntHandler);		// make sure IntHandler gets called if user hits ^C

if (!gTab.sOld[0] || !gTab.sOld[1])
	MyErr("gTab.sOld[0]==NULL || !gTab.sOld[1]==NULL");

lprintf("TEST SET ");
if (gTab.sPrefix[0])
	lprintf("%s ", gTab.sPrefix);
if (gTab.sOld[0][0])
	lprintf("%s ", gTab.sOld[0]);
if (gTab.sOld[1][0])
	lprintf("%s ", gTab.sOld[1]);
lprintf("\n");

// make sure there is a terminating "" in sNew

for (int i = 0; gTab.sNew[i]; i++)
	;
if (i == 0)
	MyErr("No entries in sOld");
if (gTab.sNew[i-1][0] != 0)			// if last entry is not ""
	gTab.sNew[i] = "";				// then create a new entry which is ""

// count the number of old strings

for (int nGroups = 0; gTab.sOld[nGroups] != NULL && gTab.sOld[nGroups][0] != 0; nGroups++)
	;

if (nGroups > 2)
	MyErr("There can be a maximum of 2 old strings, you have %d", nGroups);

// fill in pNew: pNew[iGroup] points to the first entry in sNew for each parameter group

if (gTab.sNew == NULL || gTab.sNew[0] == 0)
	MyErr("No entries in sNew");
gTab.pNew[0] = &gTab.sNew[0];
lprintf("%s: ", gTab.sOld[0]);
int iGroup = 1, nTests = 1, j = 0;
for (i = 0; gTab.sNew[i]; i++)
	{
	lprintf("%s ", gTab.sNew[i]);
	j++;
	if (gTab.sNew[i][0] == 0)
		{
		gTab.pNew[iGroup] = &gTab.sNew[i+1];
		if (iGroup < nGroups)
			lprintf("\n%s: ", gTab.sOld[iGroup]);
		nTests *= (j-1);
		j = 0;
		iGroup++;
		}
	}
lprintf("\nN=%d nRand=%d nTests=%d\n", gTab.nFilesPerTest, gTab.nRand, nTests);

// make sure there are the same number of param groups are there are sOld params

if (nGroups != iGroup-1)
	MyErr("The number of parameter groups %d is not the same as the number of old strings %d", iGroup-1, nGroups);

bool fSed = (gTab.sFile[0] != 0);
if (fSed)
	{
	System(fgRun, 0, "cp %s %s", gTab.sFile, TMP_FILE);	// make a working copy of sFile
	fgNeedToRestoreModifiedFile = true;
	}
else
	lprintf("Will not run sed\n");
#if LOG_ERRS
System(fgRun, 0, "rm -f %s", ERR_FILE);	// we will append to this file so make sure it doesn't already exist
#endif
System(fgRun, 0, "rm -f ms.log");		// ditto
System(fgRun, 0, gTab.sProlog);
if (gTab.sRefTest && gTab.sRefTest[0])
	RunRefTest(fgRun);

if (fgRun)
	{
	WriteSemaFile();								// tell ModelStatsUpdate.r that reference test is complete
	Sleep(1000);									// delay 1 sec to allow ModelStatsUpdate.r to complete reading ms.dat
	}
char **pNew0 = gTab.pNew[0];
int nFilesInMsDat = 0, iMsDat = 0, iTest = 0;
clock_t StartTimeOfTests = clock();
while ((*pNew0)[0] && (*pNew0)[0] != 0)				// for each pNew0
	{
	char *sEmpty = "";								// used if there is no second paramater pNew1
	char **pNew1 = &sEmpty;
	if (gTab.sOld[1] && gTab.sOld[1][0])
		pNew1 = gTab.pNew[1];
	while (pNew1 == &sEmpty || (*pNew1)[0] != 0)		// for each pNew1 (if no pNew1 will go only once through the loop)
		{
		PossiblyPause();
		Separator();
		lprintf("TEST %d of %d: ", iTest+1, nTests);
		if (fSed)
			lprintf("%s:%s %s:%s ", gTab.sOld[0], *pNew0, gTab.sOld[1], *pNew1);
		else
			lprintf("%s %s ", *pNew0, *pNew1);

		double ElapsedTime = (double)(clock() - StartTime);
		FormatTime(sElapsedTime, ElapsedTime);
		lprintf("[Elapsed %s", sElapsedTime);

		if (iTest)
			{
			// estimate remaining time
			double ElapsedTime1 = (double)(clock() - StartTimeOfTests);
			double TotalTime = nTests * ElapsedTime1 / iTest;
			char sRemainingTime[SLEN];
			FormatTime(sRemainingTime, TotalTime - ElapsedTime);
			time_t ltime; time(&ltime); ltime += (TotalTime - ElapsedTime) / CLOCKS_PER_SEC;
			char sTimeDone[SLEN]; strcpy(sTimeDone, ctime(&ltime));		// format "Wed Jan 02 02:03:55 1980\n"
			sTimeDone[16] = 0;
			lprintf(" Remaining %s Finish at %s", sRemainingTime, sTimeDone+11);
			}
		lprintf("]\n");

		if (fSed)
			{
			CreateSedFile(fgRun, SED_FILE, gTab.sSedPrefix, gTab.sSedPrefixReplace, gTab.sOld[0], *pNew0, gTab.sOld[1], *pNew1);
			System(fgRun, 0, "sed -f %s %s >%s", SED_FILE, TMP_FILE, gTab.sFile);
			if (gTab.sTouch && gTab.sTouch[0])
				System(fgRun, 0, "touch %s", gTab.sTouch);
			System(fgRun, 0, gTab.sMake, RELEASE);
			}
		if (gTab.sBuild && gTab.sBuild[0])
			{
			const char *sModelName = sGetModelName(gTab.sPrefix, *pNew0, *pNew1, 
													gTab.sOld[0], gTab.sOld[1]);
			CheckCmdParams(fgRun, gTab.sBuild, true);
			bool fSkipBuild = false;

			// find -o sAsmFile

			char s[LSLEN]; strcpy(s, gTab.sBuild);	// working copy

			char *pDest = strstr(s, "-o");
			if (!pDest)
				MyErr("No -o in %s", s);

			// set sToken to filename following -o

			char *sWhiteSpace = " \t";
			char *sToken = strtok(pDest+2, sWhiteSpace);
			if (sToken == NULL)
				MyErr("No filename following -o in %s", gTab.sBuild);

			if (gTab.fSkipBuildIfAsmFileExists && fFileExists(sReplaceS(sToken, sModelName)))
				lprintf(">Skipping unnecessary %s\n", sReplaceS(gTab.sBuild, sModelName));
			else
				System(fgRun, 0, sReplaceS(gTab.sBuild, sModelName));
			}
		if (fgRun)
			Sleep(1000);	// delay 1 sec to allow ModelStatsUpdate.r to complete reading ms.dat

		if (gTab.fAr)
			RunMs(fgRun, gTab.sTest, 'a', gTab.fUseMirroredFiles, 
				gTab.sMsPParam, gTab.nFilesPerTest, gTab.nRand, 
				sGetModelName(gTab.sPrefix, *pNew0, *pNew1, gTab.sOld[0], gTab.sOld[1]));
		if (gTab.fBioId)
			RunMs(fgRun, gTab.sTest, 'B', gTab.fUseMirroredFiles, 
				gTab.sMsPParam, gTab.nFilesPerTest, gTab.nRand, 
				sGetModelName(gTab.sPrefix, *pNew0, *pNew1, gTab.sOld[0], gTab.sOld[1]));
		if (gTab.fXm2vts)
			RunMs(fgRun, gTab.sTest, 'm', gTab.fUseMirroredFiles, 
				gTab.sMsPParam, gTab.nFilesPerTest, gTab.nRand, 
				sGetModelName(gTab.sPrefix, *pNew0, *pNew1, gTab.sOld[0], gTab.sOld[1]));

		if (fgRun)
			WriteSemaFile();		// tell ModelStatsUpdate.r that test is complete

		nFilesInMsDat += 3 * gTab.nFilesPerTest;
		iTest++;
		if (pNew1 == &sEmpty)
			break;
		pNew1++;
		}
	if (nFilesInMsDat > MAX_MS_DAT)
		{
		// prevent ms.dat from getting too big by splitting it into pieces
		System(fgRun, 0, "mv out/ms.dat out/ms%d.dat", iMsDat++);
		nFilesInMsDat = 0;
		if (gTab.sRefTest && gTab.sRefTest[0])
			{
			if (fgNeedToRestoreModifiedFile)
				{
				lprintf("Restoring %s for re-run of reference test", gTab.sFile);
				System(true, 0, "cp %s %s", TMP_FILE, gTab.sFile);
				fgNeedToRestoreModifiedFile = false;
				if (gTab.sTouch && gTab.sTouch[0])
					System(fgRun, 0, "touch %s", gTab.sTouch);
				System(fgRun, 0, gTab.sMake, RELEASE);
				}
			RunRefTest(fgRun);
			}
		}
	pNew0++;
	}
if (fgRun)
	Sleep(1000);	// delay 1 sec to allow ModelStatsUpdate.r to see semaphore before deleting it in MyShutdown

if (iMsDat && nFilesInMsDat)	// make sure files either just ms.dat or sequence ms0.dat ms1.dat ...
	System(fgRun, 0, "mv out/ms.dat out/ms%d.dat", iMsDat++);
Separator();
#if LOG_ERRS
System(fgRun, 0, "cat %s", ERR_FILE);
#endif
double ElapsedTime = (double)(clock() - StartTime);
FormatTime(sElapsedTime, ElapsedTime);

if (iMsDat == 0)
	lprintf("Results in out/ms.dat [%s]\n", sElapsedTime);
else
	lprintf("Results in out/ms%[0-%d].dat [%s]\n", iMsDat-1, sElapsedTime);

MyShutdown();

if (fgRun && gTab.fPlaySoundWhenDone && ElapsedTime/CLOCKS_PER_SEC > 600)	// play sound if more than 5 minutes execution time
	{
	lprintf("RING");
	PlaySound("c:/windows/Media/ringin.wav", NULL, SND_FILENAME|SND_SYNC);
	lprintf("\n");
	}
return 0;
}