sample.cpp

这是个人脸识别程序

// $masm\sample.cpp 1.5 milbo$ functions for dealing with samples
// Warning: this is raw research code -- expect it to be quite messy.
// milbo petaluma mar 2006
//-----------------------------------------------------------------------------
// 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"

//-----------------------------------------------------------------------------
static void ReadSampleFile (Mat &nEntries, Mat &iSamples, char sFileTypes[],	// out
					const char sFile[], bool fVerbose) 					// in
{
lprintf("\nReading %s ", sFile);

FILE *pFile = fopen(sFile, "r");		// Fopen checks internally if file opens ok and issues err msg if need be
if (!pFile)
	Err("Can't open %s", sFile);

// read magic number

char s[SLEN];
if (NULL == fgets(s, PLEN-1, pFile))
	Err("Can't read %s", sFile);
if (s[0] != 'S' || s[1] != 'A' || s[2] != 'M')
	SysErr("%s is not a sample file (first three chars aren't \"SAM\")", sFile);

// read FileTypes

if (NULL == Fgets(s, PLEN-1, pFile))
	Err("Can't read %s", sFile);

char sTemp[SLEN];
if (2 != sscanf(s, "%s %s", sTemp, sFileTypes) || strcmp("FileTypes", sTemp))
	SysErr("Expected \"FileTypes STRING\", got %s", s);

int nFileTypes = strlen(sFileTypes);
for (int i = 0; i < nFileTypes; i++)
	if (NULL == (strchr(sgLegalFileTypes, sFileTypes[i])))
		SysErr("Illegal filetype %c", sFileTypes[i]);

// read arrays

nEntries.sread(sFile, pFile, NULL, fVerbose, EXIT_ON_ERR);
iSamples.sread(sFile, pFile, NULL, fVerbose, EXIT_ON_ERR);

fclose(pFile);

if (nEntries.nrows() != nFileTypes)
	SysErr("Expected %d file types (to match length of \"%s\") types in nSamples, got %d", nFileTypes, sFileTypes, nEntries.nrows());

if (iSamples.ncols() < 2)
	SysErr("Expected at least two columns in iSamples, got %d", iSamples.ncols());

//if (iSamples.nrows() != nExpectedNbrOfSamples)
//	SysErr("nrows %d != nExpectedNbrOfSamples %d", iSamples.nrows(), nExpectedNbrOfSamples);
}

//-----------------------------------------------------------------------------
// Format of fSampleSpec is FILE:FileType:iSet:-I:N

void ParseSampleSpec (tSampleSpec &SampleSpec, 			// out
						const char *sSampleSpec)		// in
{
char *sToken = strtok((char *)sSampleSpec, ":");
if (!sToken)
	Err("Can't get filename from sample spec %s", sSampleSpec);
strcpy(SampleSpec.sFile, sToken);

sToken = strtok(NULL, ":");
if (!sToken)
	Err("Can't get FileType from sample spec %s", sSampleSpec);
if (sToken[1] != 0 || (sToken[0] != '*' && NULL == (strchr(sgLegalFileTypes, sToken[0]))))
	Err("Filetype in sample spec %s must be \"*\" or one of \"%s\"", sSampleSpec, sgLegalFileTypes);
strcpy(SampleSpec.sFileTypes, sToken);

sToken = strtok( NULL, ":");
if (!sToken || sscanf(sToken, "%d", &SampleSpec.iSet) != 1)
	Err("Can't get iSet from sample spec %s", sSampleSpec);

sToken = strtok( NULL, ":");
if (!sToken || sscanf(sToken, "%d", &SampleSpec.i) != 1)
	Err("Can't get I from sample spec %s", sSampleSpec);

sToken = strtok( NULL, ":");
if (!sToken || sscanf(sToken, "%d", &SampleSpec.n) != 1)
	Err("Can't get N from sample spec %s", sSampleSpec);

lprintf("SampleSpec parses to\n");
lprintf("  sFile %s\n", SampleSpec.sFile);
lprintf("  sFileTypes %s\n", SampleSpec.sFileTypes);
lprintf("  iSet %d \n", SampleSpec.iSet);
lprintf("  i %d\n", SampleSpec.i);
lprintf("  n %d\n", SampleSpec.n);
}

//-----------------------------------------------------------------------------
// This is a bit inefficient because it creates NewShapes then copies that back to Shapes
// TODO add cross check that nSamples matches shapes file

void GetShapesSpecifiedBySampleSpec (ShapeVec *pShapes, StringVec &TagStrings, 		// io
									 const tSampleSpec &SampleSpec, bool fVerbose)	// in
{
Mat nEntries;
Mat iSamples;
char sFileTypes[SLEN];
ReadSampleFile(nEntries, iSamples, sFileTypes, SampleSpec.sFile, fVerbose);

DASSERT(pShapes->size() == TagStrings.size());
ShapeVec NewShapes(pShapes->size());
StringVec NewTags(TagStrings.size());

int nFileTypes = nEntries.nrows();
int iSample = 0;
int iSet = SampleSpec.iSet;
for (int iFileType = 0; iFileType < nFileTypes; iFileType++)
	{
	for (int iSampleForThisFileType = 0; iSampleForThisFileType < nEntries(iFileType, iSet); iSampleForThisFileType++)
		{
		int iShape = iSamples(iSample, iSet);
		NewShapes[iSample] = (*pShapes)[iShape];

		string sTag = TagStrings[iShape].c_str();
		lprintf("%d %c <- %d %s\n", iSample, sFileTypes[iFileType], iShape, sTag.c_str());
		if (sTag[FNAME_OFFSET] != sFileTypes[iFileType])
			SysErr("Expected filetype %c but got %s", sFileTypes[iFileType], sTag.c_str());
		NewTags[iSample] = sTag;
		iSample++;
		}
	}
NewShapes.resize(iSample);		// discard unused entries
NewTags.resize(iSample);

pShapes->resize(0); pShapes->resize(iSample); // have to set Mat sizes to 0 else get "SysErr: mats not conformable"
*pShapes = NewShapes;							// vector assignment
TagStrings = NewTags;						// likewise

lprintf("Shapes after sampling\n");
//PrintMatVec(*pShapes)
for (int i = 0; i < TagStrings.size(); i++)
	lprintf("%s\n", TagStrings[i].c_str());
Err("early");
}