OperatorConsole.cpp

/****************************************************************************
*	Operator Console - an extensible user interface for the Imatest IT 		*
*	library																	*
*	Copyright (C) 2013 Imatest LLC.											*
*																			*
*	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 3 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.							*
*																			*
*	You should have received a copy of the GNU General Public License		*
*	along with this program.  If not, see <http://www.gnu.org/licenses/>. 	*
****************************************************************************/

///
/// OperatorConsole.cpp : Defines the class behaviors for the application.
///

#include "stdafx.h"
#include "Config.h"
#include "imatest_library.h"
#include "imatest_acquisition.h"
#include "OperatorConsole.h"
#include "OperatorConsoleDlg.h"
#include "Setup.h"
#include "PassFail.h"
#include "PasswordDialog.h"
#include "ImatestSourceIDs.h"
#include <sstream>
#include <string>
#include "logger.h"
#include "logger_preferences.h"
#include <locale>
#include "ini_helpers.h"

// This REDIRECT_STDIO causes crashes on 'quit', and I'm not seeing what extra stdout data is displayed in the GUI when it is switched on.
// #define REDIRECT_STDIO				// this redirects stdout and stderr to log window using pipes and threads
#define STDIO_DEBUG				// turns on some calls printf and cout (for debugging)
#define STDOUT_BUFSIZE	32768		// this is the desired buffer size for the redirected stdout
#define START_TEST_FROM_FRAME_READY	// test (blemish or sfrplus) will be started in OnFrameReady() rather than OnStart()

//#define NO_LOG					// turns off log messages generated by the COperatorConsoleApp object
#define USE_RGB_DATA				// if defined image data is in rgb format, otherwise it's in raw format
//TODO Rename "LOG_FILENAME"
#define LOG_FILENAME ".\\log.txt"	// contents of log window will be saved to this file when the program exits

// This CLogger and its associated handler is meant for logging details about the Operator Console's operations, not Imatest IT per se.
static CLogger logger("OperatorConsole");

static CFileLogHandler fileLogHandler(LOGGER_LEVEL, LOG_FILE_NAME); // A file extension is not necessary; *.log is automatically appended.



// COperatorConsoleApp
BEGIN_MESSAGE_MAP(COperatorConsoleApp, CWinApp)
	ON_COMMAND(ID_HELP, &CWinApp::OnHelp)

END_MESSAGE_MAP()

///
/// Converts the entry<T>.value into a std::string to facilitate writing to the pass/fail file
///
template <typename T> const std::string writeEntValueString(const entry<T>& ent)
{
	stringstream ss;

	ss << ent.value;

	return ss.str();
}
///
/// Converts the entry<CString>.value into a std::string to facilitate writing to the pass/fail file
///
template <> const std::string writeEntValueString(const entry<CString>& ent)
{
	stringstream ss;

	ss << ent.value.GetString();

	return ss.str();
}
///
/// Converts the minMaxEntry<CString>.min_val and .max_val into a std::string to facilitate writing to the pass/fail file
///
template <typename T> const std::string writeMinMaxEntValueString(const minMaxEntry<T>& ent)
{
	stringstream ss;

	ss << ent.min_val << " " << ent.max_val;
	return ss.str();
}

///
/// Converts the vecEntry<CString>.value into a single std::string to facilitate writing to the pass/fail file
///
template <typename T> const std::string writeVecEntValueString(const vecEntry<T>& ent)
{
	stringstream ss;

	for (std::size_t idx = 0; idx < ent.value.size(); ++idx)
	{
		ss << ent.value[idx] << " ";
	}
	return ss.str();

}

///
/// Conditionally adds a particular key (variable name) and value to the std::vector<std::string> keys, vals if the particular key is in use by the pass/fail file
///
void addKeysAndValues(const std::string& candidateKey, const std::string& candidateVal, std::vector<std::string>& keys, std::vector<std::string>& vals, bool b_addKey)
{
	if (b_addKey)
	{
		keys.push_back(candidateKey);
		vals.push_back(candidateVal);
	}
}

///
/// Adds a data_type string and key string to the std::vector<std::string> data_types and keys, respectively
///
void addDataTypeAndKey(const std::string& candidateDT, const CString& candidateKey, std::vector<std::string>& data_types, std::vector<CString>& keys)
{
	data_types.push_back(candidateDT);
	keys.push_back(candidateKey);
}

/// COperatorConsoleApp construction


COperatorConsoleApp::COperatorConsoleApp()
{
	// support Restart Manager
	m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART;

	// Place all significant initialization in InitInstance
	m_acq = NULL;
	m_testControl = NULL;
	m_test = NULL;
	m_fileImage = NULL;
	m_cameraImage = NULL;
	m_jsonDlgThread = NULL;
	m_config = NULL;
	memset(&m_flags, 0, sizeof(m_flags));
	m_PFSettings.m_ini_file = _T(INI_FILENAME);
	m_PFSettings.m_ini_file.Remove('\n');
	m_PFSettings.m_ini_file.Remove('\r');
	m_password = _T(ADMIN_PASSWORD);
#ifdef NO_AUTHORIZATION
	m_passFailIsUnlocked = true; // Keep this initialized to false unless you want to completely disable password-protection for pass/fail settings!
#else
	m_passFailIsUnlocked = false; // Keep this initialized to false unless you want to completely disable password-protection for pass/fail settings!
#endif
	m_image_source = imatest_source;
	m_logFileName = _T(LOG_FILENAME);
#if defined(STDIO_DEBUG)
	printf("Hello from constructor [stdout]\n");
	cout << "Hello from constructor [cout]" << endl;
#endif
}

COperatorConsoleApp::~COperatorConsoleApp()
{
	if (m_fileImage != NULL)
	{
		delete[] m_fileImage;
	}

	if (m_cameraImage != NULL)
	{
		delete[] m_cameraImage;
	}

}

/// The one and only COperatorConsoleApp object
COperatorConsoleApp theApp;


/// COperatorConsoleApp initialization

BOOL COperatorConsoleApp::InitInstance()
{
	logger.AddHandler(&fileLogHandler);

#if defined(STDIO_DEBUG)
	printf("Hello from %s [stdout]\n", __FUNCTION__);
	cout << "Hello from" << __FUNCTION__ << "[cout]" << endl;
#endif

	//TODO: call AfxInitRichEdit2() to initialize richedit2 library.
	// InitCommonControlsEx() is required on Windows XP if an application
	// manifest specifies use of ComCtl32.dll version 6 or later to enable
	// visual styles.  Otherwise, any window creation will fail.
	INITCOMMONCONTROLSEX InitCtrls;
	InitCtrls.dwSize = sizeof(InitCtrls);
	// Set this to include all the common control classes you want to use
	// in your application.
	InitCtrls.dwICC = ICC_WIN95_CLASSES;
	InitCommonControlsEx(&InitCtrls);

	CWinApp::InitInstance();


	AfxEnableControlContainer();
	AfxInitRichEdit();	// this must be called once before displaying a dialog that uses RichEdit control

	// Create the shell manager, in case the dialog contains
	// any shell tree view or shell list view controls.
	CShellManager *pShellManager = new CShellManager;

	// Activate "Windows Native" visual manager for enabling themes in MFC controls
	CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));

	m_pMainWnd = NULL;

	InitOutput();	// this sets up a pipe for handling stdout results from the DLLs


#if defined(STDIO_DEBUG)
	fprintf(stdout, "Hello from stdout.\n");	// for debugging
	fprintf(stderr, "Hello from stderr.\n");	// for debugging
	cout << "Hello from cout." << endl;			// for debugging
#endif


	if (!InitLibs()) // InitLibs must be called before any calls to Imatest library functions
	{
		cerr << "Unable to initialize the Imatest library." << endl;
		SEVERE_LOG(logger, "Unable to initialize the Imatest library.");
	}


	if (!ReadINISettings()) // if we're unable to read the ini file, we must generate image dimensions from user input before continuing
	{
		m_setup.width = 640;
		m_setup.height = 480;
		cout << "INI settings for Operator Console not found." << endl;
		cout << "Please click the 'Setup' button and fill in the" << endl;
		cout << "appropriate fields before proceeding." << endl;
		WARNING_LOG(logger, "INI settings for Operator Console not found. Please click the 'Setup' button and fill in the appropriate fields before proceeding.");

	}
	if (!ReadPassFail())
	{
		WARNING_LOG(logger, "Unable to read the pass/fail file.")
	}
	if (!Init())	// do our application-specific initialization
	{
		cout << "Application Initialization Failed" << endl;
		SEVERE_LOG(logger, "Application Initialization Failed");
		Quit();	// if init failed, clean up anything that was done in Init()
	}
	else
	{
		COperatorConsoleDlg dlg;
		m_pMainWnd = &dlg;
		INT_PTR nResponse = dlg.DoModal();
		if (nResponse == IDOK)
		{
			// TODO: Place code here to handle when the dialog is
			//  dismissed with OK
		}
		else if (nResponse == IDCANCEL)
		{
			// TODO: Place code here to handle when the dialog is
			//  dismissed with Cancel
		}
		else if (nResponse == -1)
		{
			TRACE(traceAppMsg, 0, "Warning: dialog creation failed, so application is terminating unexpectedly.\n");
			TRACE(traceAppMsg, 0, "Warning: if you are using MFC controls on the dialog, you cannot #define _AFX_NO_MFC_CONTROLS_IN_DIALOGS.\n");
		}

	}

	Quit(); // This was originally missing, but I think it should be here TDC
	CloseLibs();


	// Delete the shell manager created above.
	if (pShellManager != NULL)
	{
		delete pShellManager;
	}

	// Since the dialog has been closed, return FALSE so that we exit the
	//  application, rather than start the application's message pump.
	return FALSE;
}


//////////////////////////////////////////////
///
/// Init         perform application-specific initialization
///
/// @params        none
///
/// @return value true if successful, false otherwise
///
/// Description
///    Init does the following things:
///    It checks all of the hard coded filenames to be sure that the files exist
///    It initializes the blemish and sfrplus file acquisition objects (loads the raw files into buffers)
///    It initializes the camera object
///    Allocates a buffer to hold a single image frame
///    Creates and starts the blemish and sfrplus threads
///    Creates and starts the modeless dialog thread
///    Initializes the MATLAB and ImatestIT libraries
///    Initializes the blemish and sfrplus modules
///
/// If any of the initialization steps fails, an appropriate message is displayed in an Alert Box.
/////////////////////////////////////////////
bool COperatorConsoleApp::Init()
{
	CString	errMsg;
	bool	success = false;

	FINEST_LOG(logger, "Entering COperatorConsoleApp::Init().");

#ifdef IMATEST_CAMERA
	//m_width  = CAMERA_WIDTH;
	//m_height = CAMERA_HEIGHT;
#elif !defined FAKE_CAMERA
	m_width = CAMERA_WIDTH;
	m_height = CAMERA_HEIGHT;
#else
	m_width = RAW_WIDTH_BLEMISH;
	m_height = RAW_HEIGHT_BLEMISH;
#endif

	//
	// Initialize the Config object.  These values are used in the calls to blemish_shell() and sfrplus_shell().  
	// Right now they're all hard coded (they're defined in OperatorConsole.h)
	//
	
	m_configRAW.Init(m_setup.ini_file, PROGRAMPATH, RAW_EXTENSION, FILE_ROOT, SERIAL_NUMBER, PART_NUMBER, 1);
	m_configRGB.Init(m_setup.ini_file, PROGRAMPATH, RGB_EXTENSION, FILE_ROOT, SERIAL_NUMBER, PART_NUMBER, 3);



#if defined USE_RGB_DATA	
	m_config = &m_configRGB;
#else
	m_config = &m_configRAW;
#endif

	m_setup.program_path = m_config->m_programPath;

	if (!CheckFiles(errMsg))	// make sure that all of the hard coded files exist
	{
		SEVERE_LOG(logger, "CheckFiles() failed.");
		success = false;
	}
	else if (!InitBlemishAcq())	// loads the raw blemish file into a buffer
	{
		SEVERE_LOG(logger, "InitBlemishAcq() failed.");
		errMsg = m_blemishAcq.GetInfo();
	}
	else if (!InitSFRplusAcq())	// loads the raw sfrplus file into a buffer
	{
		SEVERE_LOG(logger, "InitSFRplusAcq failed.");
		errMsg = m_sfrPlusAcq.GetInfo();
	}
	else if (!InitCamera())
	{
		SEVERE_LOG(logger, "InitCamera() failed.");
		errMsg = m_camera->GetInfo();
	}
	else if (!AllocateImageBuf())	// allocate a buffer large enough to hold an image [must be done after call to m_blemishAcq.Open()]
	{
		SEVERE_LOG(logger, "AllocateImageBuf() failed.");
		errMsg = "Unable to allocate image buffers.";
	}
	else if (!InitBlemishThread())
	{
		SEVERE_LOG(logger, "InitBlemishThread() failed.");
		errMsg = "Unable to create Blemish thread.";
	}
	else if (!InitSFRplusThread())
	{
		SEVERE_LOG(logger, "InitSFRplusThread() failed.");
		errMsg = "Unable to create SFRplus thread.";
	}
	else if (!InitCameraThread())
	{
		SEVERE_LOG(logger, "InitCameraThread() failed.");
		errMsg = "Unable to create Capture thread.";
	}
	else if (!InitModelessThread())
	{
		SEVERE_LOG(logger, "InitModelessThread() failed.")
		errMsg = "Unable to create thread for modeless dialog.";
	}
	else
	{
		OnSetSFRplus(0, 0);	// the default test is set to SFRplus
		m_status = idle;

		success = true;
	}

	if (!errMsg.IsEmpty())
	{
		SEVERE_LOG(logger, errMsg);
		AfxMessageBox(errMsg);
	}
	FINEST_LOG(logger, "Exiting COperatorConsoleApp::Init().");
	return success;
}


bool COperatorConsoleApp::InitBlemishAcq()
{
	bool	success = false;
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitBlemishAcq()")
	if (m_blemishAcq.Init(RAW_WIDTH_BLEMISH, RAW_HEIGHT_BLEMISH, RAW_BLEMISH_IMAGE))
	{
		FINE_LOG(logger, "m_blemishAcq.Init succeeded.")
		success = m_blemishAcq.Open();
	}
	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitBlemishAcq()")
	return success;
}

bool COperatorConsoleApp::InitSFRplusAcq()
{
	bool	success = false;
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitSFRplusAcq()")
	if (m_sfrPlusAcq.Init(RAW_WIDTH_SFRPLUS, RAW_HEIGHT_SFRPLUS, RAW_SFRPLUS_IMAGE))
	{
		success = m_sfrPlusAcq.Open();
	}
	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitSFRplusAcq()")
	return success;
}

bool COperatorConsoleApp::InitCamera()
{
	bool	success = false;
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitCamera()");

	if (m_image_source == imatest_source)
	{
		FINE_LOG(logger, "imatest_source is selected.");
		m_camera = &m_imatest_cam;
		if (m_camera->Init(m_setup.width, m_setup.height, 4))
		{
			success = m_camera->Open();
			m_camera->m_device_ID = m_setup.epiphan_deviceID;
			m_camera->m_source_ID = m_setup.sourceID;
			m_camera->m_ini_file.assign(m_setup.ini_file);
		}

	}
	//else if (m_image_source == directshow_source)
	//{
	//	FINE_LOG(logger, "directshow_source is selected.");
	//	m_camera = &m_directshow_cam;
	//	if (m_camera->Init(m_setup.width, m_setup.height, 4))
	//	{
	//		success = m_camera->Open();
	//		m_camera->m_device_ID = m_setup.epiphan_deviceID;
	//		m_camera->m_source_ID = m_setup.sourceID;
	//		m_camera->m_ini_file.assign(m_setup.ini_file);
	//	}

	//}
	else if (m_image_source == file_source)
	{
		//	m_camera = &m_file_cam;
		//	m_camera->Init(IMAGE_NAME);
		//success = m_camera->Open();
		FINE_LOG(logger, "file_source is selected.");
		cerr << "Error! Image file loading not yet implemented." << endl;
		SEVERE_LOG(logger, "Error! Image file loading not yet implemented.");
	}

	//#ifdef IMATEST_CAMERA
	//	if (m_camera.Init(m_setup.width, m_setup.height, 4))
	//	{
	//		success = m_camera.Open();
	//		m_camera.m_device_ID = m_setup.epiphan_deviceID;
	//		m_camera.m_source_ID = m_setup.sourceID;
	//		m_camera.m_ini_file.assign(m_setup.ini_file);
	//	}
	//#elif !defined FAKE_CAMERA
	//	if (m_camera.Init(CAMERA_WIDTH, CAMERA_HEIGHT, 4))
	//	{
	//		success = m_camera.Open();
	//	}
	//#else
	//	m_camera.Init(IMAGE_NAME);
	//	success = m_camera.Open();
	//#endif
	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitCamera().");
	return success;
}

bool COperatorConsoleApp::InitBlemishThread()
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitBlemishThread()");
#if defined USE_RGB_DATA
	FINE_LOG(logger, "Initializing m_blemish with m_cameraImage.");
	m_blemish.Init(m_cameraImage, m_setup.width, m_setup.height, m_config);

#else
	FINE_LOG(logger, "Initializing m_blemish with m_fileImage.");
	m_blemish.Init(m_fileImage, m_blemishAcq.GetWidth(), m_blemishAcq.GetHeight(), m_config);
#endif

	m_flags.blemishThread = m_blemishControl.Init(MSG_BLEMISH_DONE, m_nThreadID, m_blemish.ThreadProc, &m_blemish);

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitBlemishThread().");
	return m_flags.blemishThread;
}


bool COperatorConsoleApp::InitSFRplusThread()
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitSFRplusThread()");
#if defined USE_RGB_DATA
	FINE_LOG(logger, "Initializing m_sfrPlus with m_cameraImage.");
	m_sfrPlus.Init(m_cameraImage, m_setup.width, m_setup.height, m_config);
#else
	FINE_LOG(logger, "Initializing m_sfrPlus with m_fileImage.");
	m_sfrPlus.Init(m_fileImage, m_sfrPlusAcq.GetWidth(), m_sfrPlusAcq.GetHeight(), m_config);
#endif
	m_flags.sfrplusThread = m_sfrPlusControl.Init(MSG_SFRPLUS_DONE, m_nThreadID, m_sfrPlus.ThreadProc, &m_sfrPlus);

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitSFRplusThread().");
	return m_flags.sfrplusThread;
}


bool COperatorConsoleApp::InitCameraThread()
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitCameraThread().");
	//m_flags.cameraThread = m_cameraControl.Init(MSG_FRAME_READY, m_nThreadID, m_camera.ThreadProc, &m_camera);
	m_flags.ImatestCameraThread = m_ImatestCameraControl.Init(MSG_FRAME_READY, m_nThreadID, m_imatest_cam.ThreadProc, &m_imatest_cam);

	FINE_LOG(logger, "Sending message to declare imatest_source as the current images source.");
	SendAppMessage(MSG_SET_IMATEST_CAM);

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitCameraThread().");
	return m_flags.ImatestCameraThread;
}



bool COperatorConsoleApp::InitLibs()
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitLibs().");
	CString	str;

	m_flags.matlab = mclInitializeApplication(NULL, 0);	// try to initialize the MATLAB library

	if (!m_flags.matlab)
	{
		SEVERE_LOG(logger, "mclInitializeApplication() call failed.");
		str = "Unable to initialize MATLAB library";
	}
	else
	{
		//
		// Try to initialize Blemish and SFRplus libraries
		//
		FINE_LOG(logger, "mclInitializeApplication() call succeeded.");

		m_flags.imatestIT = imatest_libraryInitialize();

		if (!m_flags.imatestIT)
		{
			SEVERE_LOG(logger, "imatest_libraryInitialize() call failed.");
			str = "Unable to initialize imatest library.";
		}
		else
		{
			FINE_LOG(logger, "imatest_libraryInitialize() call succeeded.");
		}

		m_flags.imatestAcq = imatest_acquisitionInitialize();

		if (!m_flags.imatestAcq)
		{
			SEVERE_LOG(logger, "imatest_acquisitionInitialize() call failed.");
			str = "Unable to initialize imatest acquisition library.";
		}
		else
		{
			FINE_LOG(logger, "imatest_acquisitionInitialize() call succeeded.");
		}

		
	}

	if (!str.IsEmpty())
	{
		SEVERE_LOG(logger, str);
		AfxMessageBox(str);
	}

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitLibs().");
	return m_flags.matlab && m_flags.imatestIT && m_flags.imatestAcq;
}

void COperatorConsoleApp::CloseLibs()
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::CloseLibs().");
	if (m_flags.imatestIT)
	{
		FINE_LOG(logger, "Calling imatest_libraryTerminate().");
		imatest_libraryTerminate();
		m_flags.imatestIT = false;
	}

	if (m_flags.imatestAcq)
	{
		FINE_LOG(logger, "Calling imatest_acquisitionTerminate().");
		imatest_acquisitionTerminate();
		m_flags.imatestAcq = false;
	}

	if (m_flags.matlab)
	{
		FINE_LOG(logger, "Calling mclTerminateApplication().");
		mclTerminateApplication();	// terminate MATLAB runtime
		m_flags.matlab = false;
	}
	FINEST_LOG(logger, "Exiting COperatorConsoleApp::CloseLibs().");
}

bool COperatorConsoleApp::InitModelessThread()
{
	m_jsonDlgThread = (ModelessDialogThread *)AfxBeginThread(RUNTIME_CLASS(ModelessDialogThread));

	m_flags.modelessThread = (m_jsonDlgThread != NULL);

	return m_flags.modelessThread;
}

bool COperatorConsoleApp::InitOutput()
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::InitOutput().");
	m_flags.stdOut = false;
	m_flags.stdErr = false;

#if defined REDIRECT_STDIO
	m_stdoutThread.InitThread(STDOUT_BUFSIZE, MSG_STDOUT, m_nThreadID);
	m_stderrThread.InitThread(STDOUT_BUFSIZE, MSG_STDERR, m_nThreadID);
	m_flags.stdOut = true;
	m_flags.stdErr = true;
	FINE_LOG(logger, "STDIO redirection enabled.");
#else
	FINE_LOG(logger, "STDIO redirection disabled.");
#endif
	FINEST_LOG(logger, "Exiting COperatorConsoleApp::InitOutput().");
	return m_flags.stdOut && m_flags.stdErr;
}


bool COperatorConsoleApp::AllocateImageBuf()
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::AllocateImageBuf().");

	bool fileBufSuccess = AllocateFileImageBuf(m_blemishAcq.BytesPerFrame());

	bool imageBufSuccess = AllocateCameraImageBuf(m_camera->BytesPerFrame());

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::AllocateImageBuf().");
	return fileBufSuccess && imageBufSuccess;
}

bool COperatorConsoleApp::AllocateCameraImageBuf(unsigned int numBytes)
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::AllocateCameraImageBuf().");
	m_cameraImageBufLen = numBytes;

	if (m_cameraImage != NULL)
	{
		FINE_LOG(logger, "Deallocating m_cameraImage.");
		delete[] m_cameraImage;
	}

	m_cameraImage = new char[m_cameraImageBufLen];

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::AllocateCameraImageBuf().");
	return m_cameraImage != NULL;
}

bool COperatorConsoleApp::AllocateFileImageBuf(unsigned int numBytes)
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::AllocateFileImageBuf().");

	if (m_fileImage != NULL)
	{
		FINE_LOG(logger, "Deallocating m_fileImage.");
		delete[] m_fileImage;
	}
	m_fileImage = new char[numBytes];

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::AllocateFileImageBuf().");
	return m_fileImage != NULL;
}




////////////////////////////////////
///
/// The threads and dialog communicate with the application object
/// by sending messages. This function pulls out the messages of
/// interest to us before they get intercepted by Windows or MFC.
///
///  @return value of TRUE means that we've processed the message
///	 @return values of FALSE means that Windows/MFC needs to deal with the message
///
//////////////////////////////////
BOOL COperatorConsoleApp::PreTranslateMessage(MSG* pMsg)
{
	BOOL	handled = FALSE;
	FINEST_LOG(logger, "Entering COperatorConsoleApp::PreTranslateMessage().");

	switch (pMsg->message)
	{
	case MSG_START:
		FINE_LOG(logger, "PreTranslateMessage received MSG_START.");
		OnStart((WPARAM)0, (LPARAM)0);
		handled = TRUE;
		break;

	case MSG_STOP:
		FINE_LOG(logger, "PreTranslateMessage received MSG_STOP.");
		OnStop((WPARAM)0, (LPARAM)0);
		handled = TRUE;
		break;

	case MSG_FRAME_READY:
		FINE_LOG(logger, "PreTranslateMessage received MSG_FRAME_READY.");
		OnFrameReady(pMsg->wParam, pMsg->lParam);
		break;

	case MSG_RUN_TEST:
		FINE_LOG(logger, "PreTranslateMessage received MSG_RUN_TEST.");
		OnRunTest((WPARAM)0, (LPARAM)0);
		handled = TRUE;
		break;

	case MSG_BLEMISH_DONE:
		FINE_LOG(logger, "PreTranslateMessage received MSG_BLEMISH_DONE.");
		OnBlemishDone(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;

	case MSG_SFRPLUS_DONE:
		FINE_LOG(logger, "PreTranslateMessage received MSG_SFRPLUS_DONE.");
		OnSFRplusDone(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;

	case MSG_SET_BLEMISH:
		FINE_LOG(logger, "PreTranslateMessage received MSG_SET_BLEMISH.");
		OnSetBlemish(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;

	case MSG_SET_SFRPLUS:
		FINE_LOG(logger, "PreTranslateMessage received MSG_SET_SFRPLUS.");
		OnSetSFRplus(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;

	case MSG_JSON:
		FINE_LOG(logger, "PreTranslateMessage received MSG_JSON.");
		OnShowJSON(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;

	case MSG_STDOUT:
		FINE_LOG(logger, "PreTranslateMessage received MSG_STDOUT.");
		OnUpdateStdout();
		break;

	case MSG_STDERR:
		FINE_LOG(logger, "PreTranslateMessage received MSG_STDERR.");
		OnUpdateStderr();
		break;

	case MSG_SETUP:
		FINE_LOG(logger, "PreTranslateMessage received MSG_SETUP.");
		OnSetup(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;
	case MSG_PASS_FAIL:
		FINE_LOG(logger, "PreTranslateMessage received MSG_PASS_FAIL.");
		OnPassFail(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;
	case MSG_SET_IMATEST_CAM:
		FINE_LOG(logger, "PreTranslateMessage received MSG_SET_IMATEST_CAM.");
		OnSetImatestCamera(pMsg->wParam, pMsg->lParam);
		handled = TRUE;
		break;
	//case MSG_SET_DIRECTSHOW_CAM:
	//	FINE_LOG(logger, "PreTranslateMessage received MSG_SET_DIRECTSHOW_CAM.");
	//	OnSetDirectshowCamera(pMsg->wParam, pMsg->lParam);
	//	handled = TRUE;
	//	break;
	}
	FINEST_LOG(logger, "Exiting COperatorConsoleApp::PreTranslateMessage().");
	return handled;
}

void COperatorConsoleApp::OnSetBlemish(WPARAM wParam, LPARAM lParam)
{
	m_testControl = &m_blemishControl;
	m_test = &m_blemish;
	m_acq = &m_blemishAcq;
}

void COperatorConsoleApp::OnSetSFRplus(WPARAM wParam, LPARAM lParam)
{
	m_testControl = &m_sfrPlusControl;
	m_test = &m_sfrPlus;
	m_acq = &m_sfrPlusAcq;
}


void COperatorConsoleApp::OnStart(WPARAM wParam, LPARAM lParam)	// the Start button was pressed in the dialog
{
	if (m_status != runningTest)
	{
		m_status = runningTest;
		SendAppMessage(MSG_RUN_TEST);	// send message to app to run test
	}
}

void COperatorConsoleApp::OnStop(WPARAM wParam, LPARAM lParam)
{
	m_status = idle;	// any test in progress will finish, but a new one won't be started
}

void COperatorConsoleApp::OnShowJSON(WPARAM wParam, LPARAM lParam)
{
	if (m_jsonDlgThread != NULL)
	{
		m_jsonDlgThread->SetText(m_results.json);
		m_jsonDlgThread->SetTitle(m_results.name);
		m_jsonDlgThread->Show(true);
	}
}

void COperatorConsoleApp::Quit()
{
	///
	/// This function gets called when the user wants to Quit the application (either by closing the window or
	/// pressing the Quit button).  Before we quit, we need to wait for the blemish and sfrplus threads to 
	/// finish.
	/// 
	/// We tell the threads to finish by sending a Quit message to them.  However, if a test is in progress,
	/// that thread won't process the Quit message until the test finished.  This can take a few seconds, so
	/// we post a Log message and turn on the Wait cursor until the threads finish.
	///
	CWaitCursor waitcursor;

	m_status = quitting;		// this tells us not to run another test

	if (m_flags.sfrplusThread)
	{
		m_sfrPlusControl.Quit();	// wait for the sfrplus thread to quit
		m_flags.sfrplusThread = false;
	}

	if (m_flags.blemishThread)
	{
		m_blemishControl.Quit();	// wait for the blemish thread to quit
		m_flags.blemishThread = false;
	}

	//if (m_flags.cameraThread)
	//{
	//	m_cameraControl.Quit();	// wait for the camera thread to quit
	//	m_flags.cameraThread = false;
	//}

	if (m_flags.ImatestCameraThread)
	{
		m_ImatestCameraControl.Quit(); // wait for the Imatest library camera thread to quit
		m_flags.ImatestCameraThread = false;
	}

	if (m_flags.modelessThread)
	{
		::PostThreadMessage(m_jsonDlgThread->m_nThreadID, MSG_MODELESS_QUIT, 0, 0);	// tell the json dialog thread to quit
		::WaitForSingleObject(m_jsonDlgThread->m_hThread, INFINITE);				// wait for it to quit (thread gets deleted automatically)
		m_flags.modelessThread = false;
	}
#if defined(REDIRECT_STDIO)
	if (m_flags.stdOut)
	{
		m_stdoutThread.Quit();		// close the stdout pipe and wait for the thread to quit
		m_flags.stdOut = false;
	}
	if (m_flags.stdErr)
	{
		m_stderrThread.Quit();		// close the stderr pipe and wait for the thread to quit
		m_flags.stdErr = false;
	}
#endif
	// TDC 2014/08/07 Calling SaveLog() anywhere in Quit() will NOT copy the contents of 
	// c_log as c_log.GetWindowText returns an empty string instead of the contents of c_log. Additionally,
	// if you use SetSel to set to the entire edit box, the values it returns have nStart > nStop.
	//SaveLog(LOG_FILENAME); 


}

void COperatorConsoleApp::OnRunTest(WPARAM wParam, LPARAM lParam)
{
	CString	str;

#if !defined NO_LOG
	str.Format("%s started\n", GetTestName());
	((COperatorConsoleDlg *)m_pMainWnd)->LogMessage(str);
#endif

#if !defined USE_RGB_DATA
	m_acq->GetFrame((void *)m_fileImage);	// get the latest image from the Acquisition object (will eventually come from camera
#endif

#ifdef IMATEST_CAMERA
	if (m_camera->BytesPerFrame() != m_cameraImageBufLen) {
		AllocateCameraImageBuf(m_camera->BytesPerFrame());
		m_test->Init(m_cameraImage, m_camera->GetWidth(), m_camera->GetHeight(), m_config);
	}
	m_camera->GetFrame(m_cameraImage);
	m_cameraControl->Run();	// capture 1 frame from the camera (we'll run the test after the frame is captured)
#elif !defined START_TEST_FROM_FRAME_READY
	m_testControl->Run();							// tell the thread to run 1 test (it will send our thread a message when it's done)
#else
	m_cameraControl->Run();	// capture 1 frame from the camera (we'll run the test after the frame is captured)
#endif
}

void COperatorConsoleApp::OnFrameReady(WPARAM w, LPARAM l)
{
#if defined START_TEST_FROM_FRAME_READY
	if (m_camera->BytesPerFrame() != m_cameraImageBufLen) {
		AllocateCameraImageBuf(m_camera->BytesPerFrame());
		m_test->Init(m_cameraImage, m_camera->GetWidth(), m_camera->GetHeight(), m_config);
	}

	m_camera->GetFrame(m_cameraImage);
	m_testControl->Run();	// tell the thread to run 1 test (it will send our thread a message when it's done)
#else
	int width = m_camera->GetWidth();
	int height = m_camera->GetHeight();
	((COperatorConsoleDlg *)m_pMainWnd)->UpdateImage(m_cameraImage, width, height);	// display it in the dialog
	m_cameraControl.Run();												// get another frame
#endif
}

void COperatorConsoleApp::OnBlemishDone(WPARAM wParam, LPARAM lParam)
{
	if (m_status != quitting)
	{
		UpdateResults(&m_blemish);	// right now blemish doesn't have any special results, so we can just call UpdateResults() directly

		if (m_status == runningTest)
		{
			SendAppMessage(MSG_RUN_TEST);	// send message to app to run again
		}
	}
}

void COperatorConsoleApp::OnSFRplusDone(WPARAM wParam, LPARAM lParam)
{
	if (m_status != quitting)
	{
		UpdateResultsSFRplus(&m_sfrPlus);

		if (m_status == runningTest)
		{
			SendAppMessage(MSG_RUN_TEST);	// send message to app to run again
		}
	}
}

void COperatorConsoleApp::OnUpdateStdout()
{
	GetStdoutMsg(m_stdoutThread, m_stdoutStr);
}

void COperatorConsoleApp::OnUpdateStderr()
{
	GetStdoutMsg(m_stderrThread, m_stderrStr);
}

void COperatorConsoleApp::GetStdoutMsg(StdoutThread &data, CString &str)
{
	COperatorConsoleDlg *dlg = (COperatorConsoleDlg *)m_pMainWnd;

	data.Get(str, true);			// get the message

	if (!str.IsEmpty())
	{
		str.Replace("\n", "\r\n");		// convert \n to \r\n
		dlg->LogMessage(str, false);	// copy the message to the log display in the dialog
	}
}

void COperatorConsoleApp::UpdateResultsSFRplus(ImageTest *test)
{
	COperatorConsoleDlg	*dlg = (COperatorConsoleDlg *)m_pMainWnd;
	const bool			*qso = m_sfrPlus.GetQSO(); // QSO overlay (tic-tac-toe)

	UpdateResults(test);
	dlg->UpdateQuadrants(qso);
}


void COperatorConsoleApp::UpdateResults(ImageTest *test)
{
	CString				str;
	bool				passed = test->Passed();
	COperatorConsoleDlg *dlg = (COperatorConsoleDlg *)m_pMainWnd;


#if !defined NO_LOG
	str.Format("%s took %s sec\n", test->m_name, test->m_elapsedStr);
	dlg->LogMessage(str);
#endif

#if defined START_TEST_FROM_FRAME_READY
	int width = m_camera->GetWidth();
	int height = m_camera->GetHeight();
	dlg->UpdateImage(m_cameraImage, width, height);	// display the image in the dialog
#endif

	//
	// Copy strings from the test object into our application
	// object so that we can display them in the dialog.
	//
	GetResults(test);

	//
	// Update the dialog with the test results
	//
	dlg->LogMessage(m_results.log, false);			// update any log messages from the test
	dlg->UpdateStatus(passed, m_results.failInfo);	// status (pass/fail)
	dlg->UpdateSummary(m_results.summary);			// summary (results)
	dlg->UpdateFPS(test->m_elapsed);				// frame rate

	//
	// Update the values in the json string, replacing \n with \r\n so
	// that the line breaks will work when displayed in a dialog.
	// 
	m_results.json.Replace("\n", "\r\n");
}

void COperatorConsoleApp::GetResults(ImageTest *test)
{
	test->GetSummary(m_results.summary);	// the summary results of the test (these get displayed in the dialog)
	test->GetFailInfo(m_results.failInfo);	// reasons that image failed the test
	test->GetLog(m_results.log);			// log message(s)
	test->GetName(m_results.name);			// the name of the test that was run
	test->GetJSON(m_results.json);
}

void COperatorConsoleApp::LogTime()
{
	CTime	t = CTime::GetCurrentTime();
	CString	str = t.Format("%c ");

	((COperatorConsoleDlg *)m_pMainWnd)->LogMessage(str);

}

BOOL COperatorConsoleApp::SendAppMessage(int msg)
{
	BOOL	result;

	result = ::PostThreadMessage(m_nThreadID, msg, 0, 0);

	return result;
}


bool COperatorConsoleApp::CheckFiles(CString &msg)
{
	const char	*files[] = { LOGO_NAME, IMAGE_NAME, RAW_BLEMISH_IMAGE, RAW_SFRPLUS_IMAGE, INI_FILENAME };
	int			numFiles = sizeof(files) / sizeof(*files);
	int			i;
	char		str[256];
	bool		success = true;


	msg.Empty();

	//
	// Try to open all of the hard-coded files.  
	//
	for (i = 0; i < numFiles; i++)
	{
		if (!FileExists(files[i], str, sizeof(str)))
		{
			msg.AppendFormat("%s\r\n", str);
			success = false;
		}
	}

	return success;
}

bool COperatorConsoleApp::FileExists(LPCTSTR filePathName, char *errorMsg, int len)
{
	bool			exists;
	CFile			file;
	CFileException	exception;

	//
	// Try to open the file, and if successful, close it.  If we could open it, then it exists
	//
	if (!file.Open(filePathName, CFile::modeRead | CFile::shareExclusive, NULL, &exception))
	{
		exception.GetErrorMessage(errorMsg, len);
		exists = false;
	}
	else
	{
		file.Close();
		exists = true;
	}

	return exists;
}

void COperatorConsoleApp::SaveLog(void)
{
	SaveLog(m_logFileName);
}


void COperatorConsoleApp::SaveLog(const CString& filePathName)
{
	UINT	len;
	CString	str;
	CFile	file(filePathName, CFile::modeWrite | CFile::modeCreate);


	//
	// Copy the contents of the log window into a string
	//
	if (m_pMainWnd) {
		((COperatorConsoleDlg *)m_pMainWnd)->GetLog(str);
	}

	//
	// str may have lines ending with \r\n or just \n.  We want all lines to end with \r\n, so first we need to 
	// convert any \r\n combinations to \n.  Then we can go back and replace all of the \n characters with \r\n.
	//
	str.Replace("\r\n", "\n");
	str.Replace("\n", "\r\n");
	len = (UINT)str.GetLength();

	//
	// Write the string to a file.  Note that the file has *not* been opened in TEXT mode.
	// This means that the string will be written to the file as-is.  There will be *no*
	// automatic replacing of \n with \r\n.  That's okay, because the text from the
	// log window already has \r\n in it.
	//
	file.Write(str, len);
	file.Close();
}


void COperatorConsoleApp::OnSetup(WPARAM wParam, LPARAM lParam)
{
	FINEST_LOG(logger, "Entering COperatorConsoleApp::OnSetup()");

	int oldWidth = m_setup.width;
	int oldHeight = m_setup.height;
	int oldSourceID = m_setup.sourceID;
	int oldDirectShowID = m_setup.directshow_deviceID;

	FINE_LOG(logger, "Polling for attached devices.");
    m_setup.deviceInfos = m_imatest_cam.GetAttachedDevices();
	FINE_LOG(logger, "Done polling for devices.");
	
	CSetup setup(NULL, m_setup);
	INT_PTR nRet = setup.DoModal();
	if (IDOK == nRet)
	{
		m_setup = setup.m_setup_settings;
		m_camera->m_device_ID = m_setup.epiphan_deviceID; // update the device_ID used by acquire_image
		m_camera->m_source_ID = m_setup.sourceID; // update the source_ID used by acquire_image
		m_camera->m_ini_file.assign(m_setup.ini_file); //TDC
		m_camera->m_video_format.assign(m_setup.video_format);
		m_camera->m_device_name.assign(m_setup.device_name);

		// transfer the configuration details to the other classes
		m_config->m_iniFilePathName = m_setup.ini_file;
		m_config->m_serialNumber = m_setup.serial_number;
		m_config->m_partNumber = m_setup.part_number;
		m_config->m_programPath = m_setup.program_path;

		m_blemish.m_iniFilePathName = m_config->m_iniFilePathName;
		m_blemish.m_serialNumber = m_config->m_serialNumber;
		m_blemish.m_partNumber = m_config->m_partNumber;
		m_blemish.m_programPath = m_config->m_programPath;

		m_sfrPlus.m_iniFilePathName = m_config->m_iniFilePathName;
		m_sfrPlus.m_serialNumber = m_config->m_serialNumber;
		m_sfrPlus.m_partNumber = m_config->m_partNumber;
		m_sfrPlus.m_programPath = m_config->m_programPath;

		WriteINISettings(); // store new settings
		if (oldWidth != m_setup.width || oldHeight != m_setup.height
			|| (oldSourceID != SOURCE_OpConsoleDirectShow) && (m_setup.sourceID == SOURCE_OpConsoleDirectShow)
			|| (oldSourceID == SOURCE_OpConsoleDirectShow) && (m_setup.sourceID != SOURCE_OpConsoleDirectShow)
			|| (oldDirectShowID != m_setup.directshow_deviceID))
		{

			// TODO: Is this still necessary?
			if (m_setup.sourceID != SOURCE_OpConsoleDirectShow)
			{
				m_image_source = imatest_source;
				if (oldSourceID == SOURCE_OpConsoleDirectShow)
				{
					SendAppMessage(MSG_SET_IMATEST_CAM);
				}
			}


			// image dimensions have changed, so we must reallocate
			try
			{
				if (!ReInit())
				{
					cout << "Unable to reinitialize." << endl;
				}
			}
			catch (std::exception & ex)
			{
				cout << "Error occurred during reinitialization." << endl;
				cerr << ex.what() << endl;
			}
		}
	}

	FINEST_LOG(logger, "Exiting COperatorConsoleApp::OnSetup()");
}

///
/// This function reads in items for the setup dialog from imatest.ini
///

bool COperatorConsoleApp::ReadINISettings(void)
{

	m_setup.readImatestKeys();
	
	// TODO: Is this still necessary?
	if (m_setup.sourceID != SOURCE_OpConsoleDirectShow)
	{
		m_image_source = imatest_source;
		SendAppMessage(MSG_SET_IMATEST_CAM);
	}
	
	// we must have the width and height > 0 since we will be allocating buffers soon
	bool result = m_setup.width > 0 && m_setup.height > 0;

	return result;
}


//
// This function writes various items used in the setup dialog to imatest.ini
// 
void COperatorConsoleApp::WriteINISettings(void)
{
	m_setup.writeImatestKeys();
}

//
// This function allows for reallocation of the various image buffers when we change the image size
//
bool COperatorConsoleApp::ReInit(void)
{

	CString	errMsg;
	bool	success = false;

	m_sfrPlusControl.Quit();
	m_blemishControl.Quit();

	if (!CheckFiles(errMsg))	// make sure that all of the hard coded files exist
	{
		success = false;
	}
	else if (!InitBlemishAcq())	// loads the raw blemish file into a buffer
	{
		errMsg = m_blemishAcq.GetInfo();
	}
	else if (!InitSFRplusAcq())	// loads the raw sfrplus file into a buffer
	{
		errMsg = m_sfrPlusAcq.GetInfo();
	}
	else if (!InitCamera())
	{
		errMsg = m_camera->GetInfo();
	}
	else if (!AllocateImageBuf())	// allocate a buffer large enough to hold an image [must be done after call to m_blemishAcq.Open()]
	{
		errMsg = "Unable to allocate image buffers.";
	}
	else if (!InitBlemishThread())
	{
		errMsg = "Unable to create Blemish thread.";
	}
	else if (!InitSFRplusThread())
	{
		errMsg = "Unable to create SFRplus thread.";
	}
	else
	{
		OnSetSFRplus(0, 0);	// the default test is set to SFRplus
		m_status = idle;
		success = true;
		((COperatorConsoleDlg *)m_pMainWnd)->ReInitDialog();
	}


	if (!errMsg.IsEmpty())
	{
		AfxMessageBox(errMsg);
	}

	return success;

}


void COperatorConsoleApp::OnPassFail(WPARAM wParam, LPARAM lParam)
{

	if (!m_passFailIsUnlocked)
	{
		CPasswordDialog pwdDialog;
		INT_PTR nRetPwd = pwdDialog.DoModal();
		if (nRetPwd == IDOK && m_password.Compare(pwdDialog.getResponse()) == 0) // if the user enters the correct password and clicks 'OK'
		{
			m_passFailIsUnlocked = pwdDialog.getUnlockStatus();
			CPassFail passfail(m_PFSettings, NULL);
			INT_PTR nRet = passfail.DoModal();
			if (nRet == IDOK)
			{
				if (!m_PFSettings.b_isReadOnly)
				{
					m_PFSettings = passfail.PFSettings;
					WritePassFail();
				}
				else
				{
					cout << "Pass/Fail file is read-only. No changes were saved." << endl;
				}
			}
		}
		else if (nRetPwd == IDOK && m_password.Compare(pwdDialog.getResponse()) != 0)
		{
			cout << "Incorrect password." << endl;
		}
	}
	else
	{
		CPassFail passfail(m_PFSettings, NULL);
		INT_PTR nRet = passfail.DoModal();
		if (nRet == IDOK)
		{
			if (!m_PFSettings.b_isReadOnly)
			{
				m_PFSettings = passfail.PFSettings;
				WritePassFail();
			}
			else
			{
				cout << "Pass/Fail file is read-only. No changes were saved." << endl;
			}
		}
	}
}

bool COperatorConsoleApp::ReadPassFail(void)
{
	bool result = false;

	// First we must find the name of the Pass/Fail file as listed in imatest.ini
	mwArray vararginParam = mwArray(1, 3, mxCELL_CLASS);
	mwArray readKeys = mwArray(1, 5, mxCELL_CLASS);
	mwArray inifilename(m_PFSettings.m_ini_file.GetString());
	mwArray mode("read");
	mwArray section("api");
	mwArray subsection_blank("");
	mwArray key_passFail("passFail");
	mwArray value_int("i"), value_string(""), value_double("d");
	int badval = -123456;
	std::string badstring = "-123456%^&%%$**#";
	mwArray default_0(badval), default_emptystring(badstring.c_str()), default_dbl((double)badval);
	mwSize getIndex = 1;

	getIndex = 1;
	readKeys.Get(1, getIndex++).Set(section);
#ifdef INI_INCLUDE_SUBSECTION
	readKeys.Get(1, getIndex++).Set(subsection_blank);
#endif
	readKeys.Get(1, getIndex++).Set(key_passFail);
	readKeys.Get(1, getIndex++).Set(value_string);
	readKeys.Get(1, getIndex++).Set(default_emptystring);

	vararginParam.Get(1, 1).Set(inifilename);
	vararginParam.Get(1, 2).Set(mode);
	vararginParam.Get(1, 3).Set(readKeys);

	mwArray readSett = mwArray(1, 1, mxCELL_CLASS);
	try
	{
		inifile(1, readSett, vararginParam);
	}
	catch (mwException& e)
	{
		cout << "Run Error! Unable to read Pass/Fail file" << endl;
		cerr << e.what() << endl;
		e.print_stack_trace();
	}

	mwArray readSettContainer = readSett.Get(1, 1);

	if (readSettContainer.NumberOfElements() > 0)
	{
		m_PFSettings.m_pass_fail_file.SetString(_T(readSett.Get(1, 1).Get(1, 1).ToString()));
		m_PFSettings.m_pass_fail_file.Remove('\n');
		m_PFSettings.m_pass_fail_file.Remove('\r');
	}
	else
	{
		/// inifile failed
		cout << "Run Error! Unable to read Pass/Fail file" << endl;
	}
	//Now we find the Pass/Fail file and check if it is read-only


	if (GetFileAttributes(m_PFSettings.m_pass_fail_file) % 2 == 1) // this returns an odd number if and only if the file is read-only
	{
		m_PFSettings.b_isReadOnly = TRUE;
	}

	// Next we need to figure out which pass/fail modules are in the ini. We will just 'readAll', which returns the full list of sections.
	//[keys,sections,subsections] = INIFILE(fName,'readall')

	mwArray keys;
	mwArray sections;
	mwArray subsections;
	mwArray passFailFile(m_PFSettings.m_pass_fail_file.GetString());
	mwArray mode_readall("readall"), mode_read("read");
#ifdef INI_INCLUDE_SUBSECTION
	int numArgOut = 3;
#else
	int numArgOut = 2;
#endif
	mwArray varargout = mwArray(1, numArgOut, mxCELL_CLASS);

	varargout.Get(1, 1).Set(keys);
	varargout.Get(1, 2).Set(sections);
#ifdef INI_INCLUDE_SUBSECTION
	varargout.Get(1, 3).Set(subsections);
#endif

	mwArray varargin = mwArray(1, 2, mxCELL_CLASS);
	varargin.Get(1, 1).Set(passFailFile);
	varargin.Get(1, 2).Set(mode_readall);
	try
	{

		inifile(numArgOut, varargout, varargin);
	}
	catch (mwException& e)
	{
		cout << "Run Error! Unable to read Pass/Fail file" << endl;
		cerr << e.what() << endl;
		e.print_stack_trace();
	}

	std::size_t numSections = varargout.Get(1, 2).NumberOfElements();
	for (std::size_t idx = 1; idx <= numSections; ++idx)
	{
		CString section = _T(varargout.Get(1, 2).Get(1, idx).ToString());

		section.Remove('\n');
		section.Remove('\r');

		if (section.CompareNoCase(_T("SFRplus")) == 0)
		{
			m_PFSettings.sfrplus.b_enable = true;
		}
		else if (section.CompareNoCase(_T("Blemish")) == 0)
		{
			m_PFSettings.blemish.b_enable = true;
		}
		else if (section.CompareNoCase(_T("OIS")) == 0)
		{
			m_PFSettings.ois.b_enable = true;
		}
		else
		{
			m_PFSettings.other.b_enable = true;
			m_PFSettings.other.name = section;
		}
	}

	// Next we can read in the keys for the 'other' section from what we already have for which all values are strings

	// Section index is different for 4.2
#ifdef INI_INCLUDE_SUBSECTION
	mwSize sectionIndex = 1;
#else
	mwSize sectionIndex = 2;
#endif

	/*
	if (m_PFSettings.other.b_enable)
	{
		mwArray dims = varargout.Get(1,1).GetDimensions();
		std::vector<int> vdims;
		std::size_t arr_dims = varargout.Get(1,1).NumberOfDimensions();

		vdims.resize(arr_dims);

		dims.GetData(&vdims[0], arr_dims);
		std::size_t numRows = (std::size_t)vdims[0];
		for (std::size_t idx=1; idx <=numRows; ++idx)
		{
			CString section = _T(varargout.Get(1,sectionIndex).Get(2,idx,1).ToString());
			section.Remove('\n');
			section.Remove('\r');
			CString cstrkey;
			CString cstrval;
			entry<CString> ent;
			if (section.CompareNoCase(m_PFSettings.other.name) ==0)
			{
				cstrkey = _T(varargout.Get(1,1).Get(2,idx,3).ToString());
				cstrkey.Remove('\n');
				cstrkey.Remove('\r');
				cstrval = _T(varargout.Get(1,1).Get(2,idx,4).ToString());
				cstrval.Remove('\n');
				cstrval.Remove('\r');
				ent.name = cstrkey;
				ent.value = cstrval;
				ent.data_type = "";
				ent.description = _T("");
				m_PFSettings.other.ent_vec.push_back(ent);
			}
		}


	}
	*/
	// Now we get to read in the other sections in a manner that respects their data type since a few of the inputs are vectors.
	// Now is a good time to grab a cup of tea...

	if (m_PFSettings.blemish.b_enable)
	{

#ifdef INI_INCLUDE_SUBSECTION
		readKeys = mwArray(m_PFSettings.blemish.numEntries, 5, mxCELL_CLASS);
#else
		readKeys = mwArray(m_PFSettings.blemish.numEntries, 4, mxCELL_CLASS);
#endif

		mwArray section_Blemish(m_PFSettings.blemish.name.GetString());

		varargin = mwArray(1, 3, mxCELL_CLASS);

		std::vector<std::string> data_types;
		std::vector<CString> blem_keys;
		// the entry<T> corresponding to a given index in blem_keys will correspond to the same index + 1 in readKeys
		addDataTypeAndKey(m_PFSettings.blemish.Blemish_maximum_count.data_type, m_PFSettings.blemish.Blemish_maximum_count.group_name, data_types, blem_keys);										// 1
		addDataTypeAndKey(m_PFSettings.blemish.Blemish_size_pixels.data_type, m_PFSettings.blemish.Blemish_size_pixels.group_name, data_types, blem_keys);											// 2
		addDataTypeAndKey(m_PFSettings.blemish.Dead_pixels_max.data_type, m_PFSettings.blemish.Dead_pixels_max.name, data_types, blem_keys);															// 3
		addDataTypeAndKey(m_PFSettings.blemish.Dead_pixel_clusters_max.data_type, m_PFSettings.blemish.Dead_pixel_clusters_max.name, data_types, blem_keys);											// 4
		addDataTypeAndKey(m_PFSettings.blemish.Defective_pixels_max_count.data_type, m_PFSettings.blemish.Defective_pixels_max_count.name, data_types, blem_keys);									// 5
		addDataTypeAndKey(m_PFSettings.blemish.Hot_pixel_clusters_max.data_type, m_PFSettings.blemish.Hot_pixel_clusters_max.name, data_types, blem_keys);											// 6
		addDataTypeAndKey(m_PFSettings.blemish.Hot_pixels_max.data_type, m_PFSettings.blemish.Hot_pixels_max.name, data_types, blem_keys);															// 7
		addDataTypeAndKey(m_PFSettings.blemish.Optical_center_offset_max.data_type, m_PFSettings.blemish.Optical_center_offset_max.name, data_types, blem_keys);										// 8
		addDataTypeAndKey(m_PFSettings.blemish.Optical_center_offset_X_max.data_type, m_PFSettings.blemish.Optical_center_offset_X_max.name, data_types, blem_keys);									// 9
		addDataTypeAndKey(m_PFSettings.blemish.Optical_center_offset_Y_max.data_type, m_PFSettings.blemish.Optical_center_offset_Y_max.name, data_types, blem_keys);									//10
		addDataTypeAndKey(m_PFSettings.blemish.Relative_illumination_corner_diff_pct_max.data_type, m_PFSettings.blemish.Relative_illumination_corner_diff_pct_max.name, data_types, blem_keys);		//11
		addDataTypeAndKey(m_PFSettings.blemish.Relative_illumination_worst_corner_pct_min.data_type, m_PFSettings.blemish.Relative_illumination_worst_corner_pct_min.name, data_types, blem_keys);	//12
		addDataTypeAndKey(m_PFSettings.blemish.Uniformity_BoverG_corners_pct_max.data_type, m_PFSettings.blemish.Uniformity_BoverG_corners_pct_max.name, data_types, blem_keys);						//13
		addDataTypeAndKey(m_PFSettings.blemish.Uniformity_RoverG_corners_pct_max.data_type, m_PFSettings.blemish.Uniformity_RoverG_corners_pct_max.name, data_types, blem_keys);						//14
		// add the contents of blem_keys and data_types to readKeys
		for (std::size_t idx = 0; idx < m_PFSettings.blemish.numEntries; ++idx)
		{
			try
			{
				mwArray key(blem_keys[idx].GetString());
				mwArray value(data_types[idx].c_str());
				mwArray default_ret;

				if (data_types[idx].compare("i") == 0)
				{
					default_ret = default_0;
				}
				else if (data_types[idx].compare("d") == 0)
				{
					default_ret = default_dbl;
				}
				else
				{
					default_ret = default_emptystring;
				}

				getIndex = 1;
				readKeys.Get(2, idx + 1, getIndex++).Set(section_Blemish);
#ifdef INI_INCLUDE_SUBSECTION
				readKeys.Get(2, idx + 1, getIndex++).Set(subsection_blank);
#endif
				readKeys.Get(2, idx + 1, getIndex++).Set(key);
				readKeys.Get(2, idx + 1, getIndex++).Set(value);
				readKeys.Get(2, idx + 1, getIndex++).Set(default_ret);
			}
			catch (exception e)
			{
				const char *c = e.what();
				std::string x = "";
			}
		}

		varargin.Get(1, 1).Set(passFailFile);
		varargin.Get(1, 2).Set(mode_read);
		varargin.Get(1, 3).Set(readKeys);

		readSett = mwArray(1, m_PFSettings.blemish.numEntries, mxCELL_CLASS);

		try
		{
			inifile(1, readSett, varargin);
		}
		catch (mwException& e)
		{
			cout << "Run Error! Unable to read Blemish keys from Pass/Fail file" << endl;
			cerr << e.what() << endl;
			e.print_stack_trace();
		}

		// now to copy the values into m_PFSettings.blemish

		std::vector<int> intVecBuf;
		std::size_t vecSize;
		mwArray temp;

		vecSize = readSett.Get(1, 1).Get(1, 1).NumberOfElements();
		intVecBuf.resize(vecSize);
		temp = readSett.Get(1, 1).Get(1, 1);
		temp.GetData(&intVecBuf[0], vecSize);
		m_PFSettings.blemish.Blemish_maximum_count.value.resize(vecSize);
		if (intVecBuf[0] != badval)
		{
			for (std::size_t idx = 0; idx < vecSize; ++idx)
			{
				m_PFSettings.blemish.Blemish_maximum_count.value[idx] = intVecBuf[idx];
			}
			m_PFSettings.blemish.Blemish_maximum_count.b_isUsed = true;
		}

		vecSize = readSett.Get(1, 1).Get(1, 2).NumberOfElements();
		intVecBuf.clear();
		intVecBuf.resize(vecSize);
		m_PFSettings.blemish.Blemish_size_pixels.value.resize(vecSize);
		temp = readSett.Get(1, 1).Get(1, 2);
		temp.GetData(&intVecBuf[0], vecSize);
		if (intVecBuf[0] != badval)
		{
			for (std::size_t idx = 0; idx < vecSize; ++idx)
			{
				m_PFSettings.blemish.Blemish_size_pixels.value[idx] = intVecBuf[idx];
			}
			m_PFSettings.blemish.Blemish_size_pixels.b_isUsed = true;
		}

		int intBuf = 0;
		double dblBuf = 0.0;

		temp = readSett.Get(1, 1).Get(1, 3);
		temp.GetData(&intBuf, 1);
		m_PFSettings.blemish.Dead_pixels_max.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 4);
		temp.GetData(&intBuf, 1);
		m_PFSettings.blemish.Dead_pixel_clusters_max.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 5);
		temp.GetData(&intBuf, 1);
		m_PFSettings.blemish.Defective_pixels_max_count.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 6);
		temp.GetData(&intBuf, 1);
		m_PFSettings.blemish.Hot_pixel_clusters_max.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 7);
		temp.GetData(&intBuf, 1);
		m_PFSettings.blemish.Hot_pixels_max.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 8);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.blemish.Optical_center_offset_max.assign_value(dblBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 9);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.blemish.Optical_center_offset_X_max.assign_value(dblBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 10);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.blemish.Optical_center_offset_Y_max.assign_value(dblBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 11);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.blemish.Relative_illumination_corner_diff_pct_max.assign_value(dblBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 12);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.blemish.Relative_illumination_worst_corner_pct_min.assign_value(dblBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 13);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.blemish.Uniformity_BoverG_corners_pct_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 14);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.blemish.Uniformity_RoverG_corners_pct_max.assign_value(dblBuf, (double)badval);


	}

	if (m_PFSettings.sfrplus.b_enable)
	{

#ifdef INI_INCLUDE_SUBSECTION
		readKeys = mwArray(m_PFSettings.sfrplus.numEntries, 5, mxCELL_CLASS);
#else
		readKeys = mwArray(m_PFSettings.sfrplus.numEntries, 4, mxCELL_CLASS);
#endif


		mwArray section_sfr(m_PFSettings.sfrplus.name.GetString());

		varargin = mwArray(1, 3, mxCELL_CLASS);

		std::vector<std::string> data_types;
		std::vector<CString> sfr_keys;
		// the entry<T> corresponding to a given index in sfr_keys will correspond to the same index + 1 in readKeys
		addDataTypeAndKey(m_PFSettings.sfrplus.All_Edge_IDs_detected.data_type, m_PFSettings.sfrplus.All_Edge_IDs_detected.name, data_types, sfr_keys);														// 1
		addDataTypeAndKey(m_PFSettings.sfrplus.Bayer_decode.data_type, m_PFSettings.sfrplus.Bayer_decode.name, data_types, sfr_keys);																			// 2
		addDataTypeAndKey(m_PFSettings.sfrplus.Chart_mean_pixel_level_bounds.data_type, m_PFSettings.sfrplus.Chart_mean_pixel_level_bounds.group_name, data_types, sfr_keys);									// 3
		addDataTypeAndKey(m_PFSettings.sfrplus.Chart_radial_pixel_shift_max.data_type, m_PFSettings.sfrplus.Chart_radial_pixel_shift_max.name, data_types, sfr_keys);											// 4
		addDataTypeAndKey(m_PFSettings.sfrplus.Color_expected_detected.data_type, m_PFSettings.sfrplus.Color_expected_detected.name, data_types, sfr_keys);													// 5
		addDataTypeAndKey(m_PFSettings.sfrplus.DeltaE_00_mean_max.data_type, m_PFSettings.sfrplus.DeltaE_00_mean_max.name, data_types, sfr_keys);
		addDataTypeAndKey(m_PFSettings.sfrplus.Convergence_angle_max.data_type, m_PFSettings.sfrplus.Convergence_angle_max.name, data_types, sfr_keys);														// 6
		addDataTypeAndKey(m_PFSettings.sfrplus.FOV_degrees_diagonal_min.data_type, m_PFSettings.sfrplus.FOV_degrees_diagonal_min.name, data_types, sfr_keys);													// 7
		addDataTypeAndKey(m_PFSettings.sfrplus.High_pixel_saturation_fraction_max.data_type, m_PFSettings.sfrplus.High_pixel_saturation_fraction_max.name, data_types, sfr_keys);								// 8
		addDataTypeAndKey(m_PFSettings.sfrplus.Horizontal_bars_OK_min.data_type, m_PFSettings.sfrplus.Horizontal_bars_OK_min.name, data_types, sfr_keys);														// 9
		addDataTypeAndKey(m_PFSettings.sfrplus.Low_pixel_saturation_fraction_max.data_type, m_PFSettings.sfrplus.Low_pixel_saturation_fraction_max.name, data_types, sfr_keys);								//10
		addDataTypeAndKey(m_PFSettings.sfrplus.Mirrored_chart.data_type, m_PFSettings.sfrplus.Mirrored_chart.name, data_types, sfr_keys);																		//11
		addDataTypeAndKey(m_PFSettings.sfrplus.MTF50P_CP_weighted_mean_min.data_type, m_PFSettings.sfrplus.MTF50P_CP_weighted_mean_min.name, data_types, sfr_keys);											//12
		addDataTypeAndKey(m_PFSettings.sfrplus.MTF50P_ratio_min.data_type, m_PFSettings.sfrplus.MTF50P_ratio_min.name, data_types, sfr_keys);																	//13
		addDataTypeAndKey(m_PFSettings.sfrplus.passfail_ini_file_date.data_type, m_PFSettings.sfrplus.passfail_ini_file_date.name, data_types, sfr_keys);														//14
		addDataTypeAndKey(m_PFSettings.sfrplus.Rotation_degrees_max.data_type, m_PFSettings.sfrplus.Rotation_degrees_max.name, data_types, sfr_keys);															//15
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_1_center_mean_min.data_type, m_PFSettings.sfrplus.Secondary_readout_1_center_mean_min.name, data_types, sfr_keys);							//16
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_1_outer_mean_min.data_type, m_PFSettings.sfrplus.Secondary_readout_1_outer_mean_min.name, data_types, sfr_keys);								//17
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_1_outer_min_min.data_type, m_PFSettings.sfrplus.Secondary_readout_1_outer_min_min.name, data_types, sfr_keys);								//18
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_delta_max.data_type, m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_delta_max.name, data_types, sfr_keys);			//19 
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_mean_min_min.data_type, m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_mean_min_min.name, data_types, sfr_keys);	//20
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_2_center_mean_min.data_type, m_PFSettings.sfrplus.Secondary_readout_2_center_mean_min.name, data_types, sfr_keys);							//21
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_2_outer_mean_min.data_type, m_PFSettings.sfrplus.Secondary_readout_2_outer_mean_min.name, data_types, sfr_keys);								//22
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_2_outer_min_min.data_type, m_PFSettings.sfrplus.Secondary_readout_2_outer_min_min.name, data_types, sfr_keys);								//23
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_delta_max.data_type, m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_delta_max.name, data_types, sfr_keys);			//24
		addDataTypeAndKey(m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_mean_min_min.data_type, m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_mean_min_min.name, data_types, sfr_keys);	//25
		addDataTypeAndKey(m_PFSettings.sfrplus.Stepchart_expected_detected.data_type, m_PFSettings.sfrplus.Stepchart_expected_detected.name, data_types, sfr_keys);											//26
		addDataTypeAndKey(m_PFSettings.sfrplus.upside_down.data_type, m_PFSettings.sfrplus.upside_down.name, data_types, sfr_keys);																			//27

		// add the contents of sfr_keys and data_types to readKeys
		for (std::size_t idx = 0; idx < m_PFSettings.sfrplus.numEntries; ++idx)
		{
			mwArray key(sfr_keys[idx].GetString());
			mwArray value(data_types[idx].c_str());
			mwArray default_ret;

			if (data_types[idx].compare("i") == 0)
			{
				default_ret = default_0;
			}
			else if (data_types[idx].compare("d") == 0)
			{
				default_ret = default_dbl;
			}
			else
			{
				default_ret = default_emptystring;
			}

			getIndex = 1;
			readKeys.Get(2, idx + 1, getIndex++).Set(section_sfr);
#ifdef INI_INCLUDE_SUBSECTION
			readKeys.Get(2, idx + 1, getIndex++).Set(subsection_blank);
#endif
			readKeys.Get(2, idx + 1, getIndex++).Set(key);
			readKeys.Get(2, idx + 1, getIndex++).Set(value);
			readKeys.Get(2, idx + 1, getIndex++).Set(default_ret);
		}

		int intBuf = 0;
		double dblBuf = 0.0;
		std::vector<int> intVecBuf;
		std::vector<double> dblVecBuf;
		varargin.Get(1, 1).Set(passFailFile);
		varargin.Get(1, 2).Set(mode_read);
		varargin.Get(1, 3).Set(readKeys);
		readSett = mwArray(1, m_PFSettings.sfrplus.numEntries, mxCELL_CLASS);

		mwArray temp;

		try
		{
			inifile(1, readSett, varargin);
		}
		catch (mwException& e)
		{
			cout << "Run Error! Unable to read SFRplus keys from Pass/Fail file" << endl;
			cerr << e.what() << endl;
			e.print_stack_trace();
		}
		// copy the values read from file to the appropriate entries in m_PFSettings.sfrplus
		temp = readSett.Get(1, 1).Get(1, 1);
		temp.GetData(&intBuf, 1);
		m_PFSettings.sfrplus.All_Edge_IDs_detected.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 2);
		temp.GetData(&intBuf, 1);
		m_PFSettings.sfrplus.Bayer_decode.assign_value(intBuf, badval);

		std::size_t vecSize = readSett.Get(1, 1).Get(1, 3).NumberOfElements();
		dblVecBuf.resize(vecSize);
		temp = readSett.Get(1, 1).Get(1, 3);
		temp.GetData(&dblVecBuf[0], vecSize);
		m_PFSettings.sfrplus.Chart_mean_pixel_level_bounds.assign_value(dblVecBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 4);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Chart_radial_pixel_shift_max.assign_value(dblBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 5);
		temp.GetData(&intBuf, 1);
		m_PFSettings.sfrplus.Color_expected_detected.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 6);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Convergence_angle_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 6);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.DeltaE_00_mean_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 7);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.FOV_degrees_diagonal_min.assign_value(dblBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 8);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.High_pixel_saturation_fraction_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 9);
		temp.GetData(&intBuf, 1);
		m_PFSettings.sfrplus.Horizontal_bars_OK_min.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 10);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Low_pixel_saturation_fraction_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 11);
		temp.GetData(&intBuf, 1);
		m_PFSettings.sfrplus.Mirrored_chart.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 12);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.MTF50P_CP_weighted_mean_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 13);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.MTF50P_ratio_min.assign_value(dblBuf, (double)badval);

		m_PFSettings.sfrplus.passfail_ini_file_date.value = _T(readSett.Get(1, 1).Get(1, 14).ToString());
		m_PFSettings.sfrplus.passfail_ini_file_date.value.Remove('\n');
		m_PFSettings.sfrplus.passfail_ini_file_date.value.Remove('\r');
		if (m_PFSettings.sfrplus.passfail_ini_file_date.value.Compare(_T(badstring.c_str())) != 0)
		{
			m_PFSettings.sfrplus.passfail_ini_file_date.b_isUsed = true;
			if (m_PFSettings.sfrplus.passfail_ini_file_date.value.Compare(_T("[]")) == 0)
			{
				m_PFSettings.sfrplus.passfail_ini_file_date.value = _T("");
			}
		}
		else
		{
			m_PFSettings.sfrplus.passfail_ini_file_date.b_isUsed = false;
		}

		temp = readSett.Get(1, 1).Get(1, 15);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Rotation_degrees_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 16);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_1_center_mean_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 17);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_1_outer_mean_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 18);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_1_outer_min_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 19);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_delta_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 20);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_mean_min_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 21);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_2_center_mean_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 22);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_2_outer_mean_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 23);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_2_outer_min_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 24);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_delta_max.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 25);
		temp.GetData(&dblBuf, 1);
		m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_mean_min_min.assign_value(dblBuf, (double)badval);

		temp = readSett.Get(1, 1).Get(1, 26);
		temp.GetData(&intBuf, 1);
		m_PFSettings.sfrplus.Stepchart_expected_detected.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1).Get(1, 27);
		temp.GetData(&intBuf, 1);
		m_PFSettings.sfrplus.upside_down.assign_value(intBuf, badval);

}

	if (m_PFSettings.ois.b_enable)
	{

		readKeys = mwArray(m_PFSettings.ois.numEntries, 5, mxCELL_CLASS);
		varargin = mwArray(1, 3, mxCELL_CLASS);
		mwArray section_ois(m_PFSettings.ois.name.GetString());
		mwArray temp;

		std::vector<std::string> data_types;
		std::vector<CString> ois_keys;

		addDataTypeAndKey(m_PFSettings.ois.L_MTF50_delta2_gain_summary_all_dB_min.data_type, m_PFSettings.ois.L_MTF50_delta2_gain_summary_all_dB_min.name, data_types, ois_keys);	// 1
		addDataTypeAndKey(m_PFSettings.ois.R_improve_ALL_dB_min.data_type, m_PFSettings.ois.R_improve_ALL_dB_min.name, data_types, ois_keys);										// 2
		addDataTypeAndKey(m_PFSettings.ois.R_improve_H_dB_min.data_type, m_PFSettings.ois.R_improve_H_dB_min.name, data_types, ois_keys);											// 3
		addDataTypeAndKey(m_PFSettings.ois.R_improve_V_dB_min.data_type, m_PFSettings.ois.R_improve_V_dB_min.name, data_types, ois_keys);											// 4
		// add the contents of ois_keys and data_types to readKeys
		for (std::size_t idx = 0; idx < m_PFSettings.ois.numEntries; ++idx)
		{
			mwArray key(ois_keys[idx].GetString());
			mwArray value(data_types[idx].c_str());
			mwArray default_ret;

			if (data_types[idx].compare("i") == 0)
			{
				default_ret = default_0;
			}
			else if (data_types[idx].compare("d") == 0)
			{
				default_ret = default_dbl;
			}
			else
			{
				default_ret = default_emptystring;
			}
			getIndex = 1;
			readKeys.Get(2, idx + 1, getIndex++).Set(section_ois);
#ifdef INI_INCLUDE_SUBSECTION
			readKeys.Get(2, idx + 1, getIndex++).Set(subsection_blank);
#endif
			readKeys.Get(2, idx + 1, getIndex++).Set(key);
			readKeys.Get(2, idx + 1, getIndex++).Set(value);
			readKeys.Get(2, idx + 1, getIndex++).Set(default_ret);
		}

		int intBuf = 0;
		double dblBuf = 0.0;
		std::vector<int> intVecBuf;

		varargin.Get(1, 1).Set(passFailFile);
		varargin.Get(1, 2).Set(mode_read);
		varargin.Get(1, 3).Set(readKeys);
		readSett = mwArray(1, m_PFSettings.ois.numEntries, mxCELL_CLASS);

		try
		{
			inifile(1, readSett, varargin);
		}
		catch (mwException& e)
		{
			cout << "Run Error!" << endl;
			cerr << e.what() << endl;
			e.print_stack_trace();
		}
		// copy the values read from file to the appropriate entries in m_PFSettings.ois
		temp = readSett.Get(1, 1);
		temp.Get(1, 1).GetData(&intBuf, 1);
		m_PFSettings.ois.L_MTF50_delta2_gain_summary_all_dB_min.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1);
		temp.Get(1, 2).GetData(&intBuf, 1);
		m_PFSettings.ois.R_improve_ALL_dB_min.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1);
		temp.Get(1, 3).GetData(&intBuf, 1);
		m_PFSettings.ois.R_improve_H_dB_min.assign_value(intBuf, badval);

		temp = readSett.Get(1, 1);
		temp.Get(1, 4).GetData(&intBuf, 1);
		m_PFSettings.ois.R_improve_V_dB_min.assign_value(intBuf, badval);
	}

	return result;
	}


bool COperatorConsoleApp::WritePassFail(void)
{
	bool result = false;

	mwArray varargin = mwArray(1, 4, mxCELL_CLASS);

	mwArray inifilename(m_PFSettings.m_ini_file.GetString());
	mwArray passfailfilename(m_PFSettings.m_pass_fail_file.GetString());
	mwArray mode("write");
	mwArray style("plain");
	mwArray subsection_blank("");
	mwArray value_int("i"), value_string(""), value_double("d");
	mwSize getIndex = 1;


	if (m_PFSettings.blemish.b_enable)
	{
		mwArray section(m_PFSettings.blemish.name.GetString());
		std::vector<std::string> keys;
		std::vector<std::string> vals;

		addKeysAndValues(m_PFSettings.blemish.Blemish_maximum_count.group_name.GetString(), writeVecEntValueString(m_PFSettings.blemish.Blemish_maximum_count), keys, vals, m_PFSettings.blemish.Blemish_maximum_count.b_isUsed);				// 1
		addKeysAndValues(m_PFSettings.blemish.Blemish_size_pixels.group_name.GetString(), writeVecEntValueString(m_PFSettings.blemish.Blemish_size_pixels), keys, vals, m_PFSettings.blemish.Blemish_size_pixels.b_isUsed);						// 2
		addKeysAndValues(m_PFSettings.blemish.Dead_pixels_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Dead_pixels_max), keys, vals, m_PFSettings.blemish.Dead_pixels_max.b_isUsed);											// 3
		addKeysAndValues(m_PFSettings.blemish.Dead_pixel_clusters_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Dead_pixel_clusters_max), keys, vals, m_PFSettings.blemish.Dead_pixel_clusters_max.b_isUsed);				// 4
		addKeysAndValues(m_PFSettings.blemish.Defective_pixels_max_count.name.GetString(), writeEntValueString(m_PFSettings.blemish.Defective_pixels_max_count), keys, vals, m_PFSettings.blemish.Defective_pixels_max_count.b_isUsed);		// 5
		addKeysAndValues(m_PFSettings.blemish.Hot_pixel_clusters_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Hot_pixel_clusters_max), keys, vals, m_PFSettings.blemish.Hot_pixel_clusters_max.b_isUsed);					// 6
		addKeysAndValues(m_PFSettings.blemish.Hot_pixels_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Hot_pixels_max), keys, vals, m_PFSettings.blemish.Hot_pixels_max.b_isUsed);											// 7
		addKeysAndValues(m_PFSettings.blemish.Optical_center_offset_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Optical_center_offset_max), keys, vals, m_PFSettings.blemish.Optical_center_offset_max.b_isUsed);			// 8
		addKeysAndValues(m_PFSettings.blemish.Optical_center_offset_X_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Optical_center_offset_X_max), keys, vals, m_PFSettings.blemish.Optical_center_offset_X_max.b_isUsed);	// 9
		addKeysAndValues(m_PFSettings.blemish.Optical_center_offset_Y_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Optical_center_offset_Y_max), keys, vals, m_PFSettings.blemish.Optical_center_offset_Y_max.b_isUsed);	//10
		addKeysAndValues(m_PFSettings.blemish.Relative_illumination_corner_diff_pct_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Relative_illumination_corner_diff_pct_max), keys, vals, m_PFSettings.blemish.Relative_illumination_corner_diff_pct_max.b_isUsed);		//11
		addKeysAndValues(m_PFSettings.blemish.Relative_illumination_worst_corner_pct_min.name.GetString(), writeEntValueString(m_PFSettings.blemish.Relative_illumination_worst_corner_pct_min), keys, vals, m_PFSettings.blemish.Relative_illumination_worst_corner_pct_min.b_isUsed);	//12 
		addKeysAndValues(m_PFSettings.blemish.Uniformity_BoverG_corners_pct_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Uniformity_BoverG_corners_pct_max), keys, vals, m_PFSettings.blemish.Uniformity_BoverG_corners_pct_max.b_isUsed);								//13
		addKeysAndValues(m_PFSettings.blemish.Uniformity_RoverG_corners_pct_max.name.GetString(), writeEntValueString(m_PFSettings.blemish.Uniformity_RoverG_corners_pct_max), keys, vals, m_PFSettings.blemish.Uniformity_RoverG_corners_pct_max.b_isUsed);								//14
		// add the contents of keys and vals to writeKeys
		mwArray writeKeys = mwArray(keys.size(), 4, mxCELL_CLASS);
		for (std::size_t idx = 0; idx < keys.size(); ++idx)
		{
			mwArray key(keys[idx].c_str());
			mwArray val(vals[idx].c_str());
			getIndex = 1;
			writeKeys.Get(2, idx + 1, getIndex++).Set(section);
#ifdef INI_INCLUDE_SUBSECTION
			writeKeys.Get(2, idx + 1, getIndex++).Set(subsection_blank);
#endif
			writeKeys.Get(2, idx + 1, getIndex++).Set(key);
			writeKeys.Get(2, idx + 1, getIndex++).Set(val);
		}

		varargin.Get(1, 1).Set(passfailfilename);
		varargin.Get(1, 2).Set(mode);
		varargin.Get(1, 3).Set(writeKeys);
		varargin.Get(1, 4).Set(style);

		try
		{
			inifile(varargin);
			result = true;
		}
		catch (mwException& e)
		{
			cout << "Run Error! Unable to write to Pass/Fail file" << endl;
			cerr << e.what() << endl;
			e.print_stack_trace();
			result = false;
		}

	}

	if (m_PFSettings.ois.b_enable)
	{
		mwArray section(m_PFSettings.ois.name.GetString());
		std::vector<std::string> keys;
		std::vector<std::string> vals;

		addKeysAndValues(m_PFSettings.ois.L_MTF50_delta2_gain_summary_all_dB_min.name.GetString(), writeEntValueString(m_PFSettings.ois.L_MTF50_delta2_gain_summary_all_dB_min), keys, vals, m_PFSettings.ois.L_MTF50_delta2_gain_summary_all_dB_min.b_isUsed);// 1
		addKeysAndValues(m_PFSettings.ois.R_improve_ALL_dB_min.name.GetString(), writeEntValueString(m_PFSettings.ois.R_improve_ALL_dB_min), keys, vals, m_PFSettings.ois.R_improve_ALL_dB_min.b_isUsed);	// 2
		addKeysAndValues(m_PFSettings.ois.R_improve_H_dB_min.name.GetString(), writeEntValueString(m_PFSettings.ois.R_improve_H_dB_min), keys, vals, m_PFSettings.ois.R_improve_H_dB_min.b_isUsed);		// 3
		addKeysAndValues(m_PFSettings.ois.R_improve_V_dB_min.name.GetString(), writeEntValueString(m_PFSettings.ois.R_improve_V_dB_min), keys, vals, m_PFSettings.ois.R_improve_V_dB_min.b_isUsed);		// 4

		mwArray writeKeys = mwArray(keys.size(), 4, mxCELL_CLASS);
		// add the contents of keys and vals to writeKeys
		for (std::size_t idx = 0; idx < keys.size(); ++idx)
		{
			mwArray key(keys[idx].c_str());
			mwArray val(vals[idx].c_str());
			getIndex = 1;
			writeKeys.Get(2, idx + 1, getIndex++).Set(section);
#ifdef INI_INCLUDE_SUBSECTION
			writeKeys.Get(2, idx + 1, getIndex++).Set(subsection_blank);
#endif
			writeKeys.Get(2, idx + 1, getIndex++).Set(key);
			writeKeys.Get(2, idx + 1, getIndex++).Set(val);
		}

		varargin.Get(1, 1).Set(passfailfilename);
		varargin.Get(1, 2).Set(mode);
		varargin.Get(1, 3).Set(writeKeys);
		varargin.Get(1, 4).Set(style);

		try
		{
			inifile(varargin);
			result = true;
		}
		catch (mwException& e)
		{
			cout << "Run Error writing OIS keys to Pass/Fail file!" << endl;
			cerr << e.what() << endl;
			e.print_stack_trace();
			result = false;
		}

		}

	if (m_PFSettings.other.b_enable)
	{
		mwArray writeKeys = mwArray(m_PFSettings.other.ent_vec.size(), 4, mxCELL_CLASS);
		mwArray section(m_PFSettings.other.name.GetString());
		// add the contents of ent_vec to writeKeys
		for (std::size_t idx = 0; idx < m_PFSettings.other.ent_vec.size(); ++idx)
		{
			mwArray key(m_PFSettings.other.ent_vec[idx].name.GetString());
			mwArray val(writeEntValueString(m_PFSettings.other.ent_vec[idx]).c_str());
			getIndex = 1;
			writeKeys.Get(2, idx + 1, getIndex++).Set(section);
#ifdef INI_INCLUDE_SUBSECTION
			writeKeys.Get(2, idx + 1, getIndex++).Set(subsection_blank);
#endif
			writeKeys.Get(2, idx + 1, getIndex++).Set(key);
			writeKeys.Get(2, idx + 1, getIndex++).Set(val);
		}

		varargin.Get(1, 1).Set(passfailfilename);
		varargin.Get(1, 2).Set(mode);
		varargin.Get(1, 3).Set(writeKeys);
		varargin.Get(1, 4).Set(style);

		try
		{
			inifile(varargin);
			result = true;
		}
		catch (mwException& e)
		{
			cout << "Run Error writing Blemish keys to Pass/Fail file!" << endl;
			cerr << e.what() << endl;
			e.print_stack_trace();
			result = false;
		}

	}

	if (m_PFSettings.sfrplus.b_enable)
	{
		mwArray section(m_PFSettings.sfrplus.name.GetString());
		std::vector<std::string> keys;
		std::vector<std::string> vals;

		addKeysAndValues(m_PFSettings.sfrplus.All_Edge_IDs_detected.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.All_Edge_IDs_detected), keys, vals, m_PFSettings.sfrplus.All_Edge_IDs_detected.b_isUsed);												// 1
		addKeysAndValues(m_PFSettings.sfrplus.Bayer_decode.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Bayer_decode), keys, vals, m_PFSettings.sfrplus.Bayer_decode.b_isUsed);																			// 2
		addKeysAndValues(m_PFSettings.sfrplus.Chart_mean_pixel_level_bounds.group_name.GetString(), writeMinMaxEntValueString(m_PFSettings.sfrplus.Chart_mean_pixel_level_bounds), keys, vals, m_PFSettings.sfrplus.Chart_mean_pixel_level_bounds.b_isUsed);			// 3
		addKeysAndValues(m_PFSettings.sfrplus.Chart_radial_pixel_shift_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Chart_radial_pixel_shift_max), keys, vals, m_PFSettings.sfrplus.Chart_radial_pixel_shift_max.b_isUsed);							// 4
		addKeysAndValues(m_PFSettings.sfrplus.Color_expected_detected.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Color_expected_detected), keys, vals, m_PFSettings.sfrplus.Color_expected_detected.b_isUsed);										// 5
		addKeysAndValues(m_PFSettings.sfrplus.DeltaE_00_mean_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.DeltaE_00_mean_max), keys, vals, m_PFSettings.sfrplus.DeltaE_00_mean_max.b_isUsed);										// 6
		addKeysAndValues(m_PFSettings.sfrplus.Convergence_angle_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Convergence_angle_max), keys, vals, m_PFSettings.sfrplus.Convergence_angle_max.b_isUsed);												// 7
		addKeysAndValues(m_PFSettings.sfrplus.FOV_degrees_diagonal_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.FOV_degrees_diagonal_min), keys, vals, m_PFSettings.sfrplus.FOV_degrees_diagonal_min.b_isUsed);										// 8
		addKeysAndValues(m_PFSettings.sfrplus.High_pixel_saturation_fraction_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.High_pixel_saturation_fraction_max), keys, vals, m_PFSettings.sfrplus.High_pixel_saturation_fraction_max.b_isUsed);		// 9
		addKeysAndValues(m_PFSettings.sfrplus.Horizontal_bars_OK_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Horizontal_bars_OK_min), keys, vals, m_PFSettings.sfrplus.Horizontal_bars_OK_min.b_isUsed);											// 10
		addKeysAndValues(m_PFSettings.sfrplus.Low_pixel_saturation_fraction_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Low_pixel_saturation_fraction_max), keys, vals, m_PFSettings.sfrplus.Low_pixel_saturation_fraction_max.b_isUsed);			//11
		addKeysAndValues(m_PFSettings.sfrplus.Mirrored_chart.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Mirrored_chart), keys, vals, m_PFSettings.sfrplus.Mirrored_chart.b_isUsed);																	//12
		addKeysAndValues(m_PFSettings.sfrplus.MTF50P_CP_weighted_mean_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.MTF50P_CP_weighted_mean_min), keys, vals, m_PFSettings.sfrplus.MTF50P_CP_weighted_mean_min.b_isUsed);							//13
		addKeysAndValues(m_PFSettings.sfrplus.MTF50P_ratio_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.MTF50P_ratio_min), keys, vals, m_PFSettings.sfrplus.MTF50P_ratio_min.b_isUsed);																//14
		addKeysAndValues(m_PFSettings.sfrplus.passfail_ini_file_date.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.passfail_ini_file_date), keys, vals, m_PFSettings.sfrplus.passfail_ini_file_date.b_isUsed);											//15
		addKeysAndValues(m_PFSettings.sfrplus.Rotation_degrees_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Rotation_degrees_max), keys, vals, m_PFSettings.sfrplus.Rotation_degrees_max.b_isUsed);													//16
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_1_center_mean_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_1_center_mean_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_1_center_mean_min.b_isUsed);	//17
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_1_outer_mean_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_1_outer_mean_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_1_outer_mean_min.b_isUsed);		//18
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_1_outer_min_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_1_outer_min_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_1_outer_min_min.b_isUsed);			//19
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_delta_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_delta_max), keys, vals, m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_delta_max.b_isUsed);			//20
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_mean_min_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_mean_min_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_1_outer_quadrant_mean_min_min.b_isUsed);//21
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_2_center_mean_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_2_center_mean_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_2_center_mean_min.b_isUsed);	//22
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_2_outer_mean_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_2_outer_mean_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_2_outer_mean_min.b_isUsed);		//23
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_2_outer_min_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_2_outer_min_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_2_outer_min_min.b_isUsed);			//24
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_delta_max.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_delta_max), keys, vals, m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_delta_max.b_isUsed);			//25
		addKeysAndValues(m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_mean_min_min.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_mean_min_min), keys, vals, m_PFSettings.sfrplus.Secondary_readout_2_outer_quadrant_mean_min_min.b_isUsed);//26
		addKeysAndValues(m_PFSettings.sfrplus.Stepchart_expected_detected.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.Stepchart_expected_detected), keys, vals, m_PFSettings.sfrplus.Stepchart_expected_detected.b_isUsed);							//27
		addKeysAndValues(m_PFSettings.sfrplus.upside_down.name.GetString(), writeEntValueString(m_PFSettings.sfrplus.upside_down), keys, vals, m_PFSettings.sfrplus.upside_down.b_isUsed);																			//28

		mwArray writeKeys = mwArray(keys.size(), 4, mxCELL_CLASS);
		// add the contents of keys and vals to writeKeys
		for (std::size_t idx = 0; idx < keys.size(); ++idx)
		{
			mwArray key(keys[idx].c_str());
			mwArray val(vals[idx].c_str());
			getIndex = 1;
			writeKeys.Get(2, idx + 1, getIndex++).Set(section);
#ifdef INI_INCLUDE_SUBSECTION
			writeKeys.Get(2, idx + 1, getIndex++).Set(subsection_blank);
#endif
			writeKeys.Get(2, idx + 1, getIndex++).Set(key);
			writeKeys.Get(2, idx + 1, getIndex++).Set(val);
		}

		varargin.Get(1, 1).Set(passfailfilename);
		varargin.Get(1, 2).Set(mode);
		varargin.Get(1, 3).Set(writeKeys);
		varargin.Get(1, 4).Set(style);

		try
		{
			inifile(varargin);
			result = true;
		}
		catch (mwException& e)
		{
			cout << "Run Error writing SFRplus keys to Pass/Fail file!" << endl;
			cerr << e.what() << endl;
			e.print_stack_trace();
			result = false;
		}
	}

	return result;
	}


void COperatorConsoleApp::OnSetImatestCamera(WPARAM wParam, LPARAM lParam)
{
	m_camera = &m_imatest_cam;
	m_cameraControl = &m_ImatestCameraControl;

}


//void COperatorConsoleApp::OnSetDirectshowCamera(WPARAM wParam, LPARAM lParam)
//{
//	int currentCameraId = m_directshow_cam.getCameraIndex();
//
//	if (currentCameraId != m_setup.directshow_deviceID)
//		m_directshow_cam.setCameraIndex(m_setup.directshow_deviceID);
//
//	m_camera = &m_directshow_cam;
//	m_cameraControl = &m_DirectShowCameraControl;
//
//}