dnaclassificationdlg.cpp

DNA分类

	case 3:
		{					
			strTest += "DNA_DATA\\testsv_62.xls";		
		}
		break;
	}
	
	//读测试样本
	return ReadTestSamples(strTest,"test");

}
//熟练
BOOL CDNAClassificationDlg::Training()
{	
	int n = m_TrainSamples.n-m_TrainSamples.nExclude;
	int c = m_TrainSamples.c;

	double** samples = new double*[n];
	int* pClass = new int[n];//类别

	int nn = 0;
	for(int jj = 0;jj<m_TrainSamples.n;jj++)
	{
		if(m_TrainSamples.pExludeSample[jj] ==1)//
		{
		}
		else 
		{
			samples[nn] = new double [c];
			for(int ii = 0;ii<c;ii++)
				samples[nn][ii] = m_TrainSamples.ppSamples[jj][ii];
			pClass[nn] = m_TrainSamples.pClass[jj];
			nn++;
		}
	}

	if(Training(samples,pClass,n,c)==FALSE)//训练
		AfxMessageBox("训练样本时出错!");
	

	//释放内存
	for(int s = 0;s<n;s++)
	{
		delete[] samples[s];		
	}
	delete[] samples;

	delete[] pClass;

	return TRUE;
}


BOOL CDNAClassificationDlg::Classify()
{
	if(Classify(m_TestSamples.ppTestSamples,m_TestSamples.pClass,
		m_TestSamples.n,m_TestSamples.c)==FALSE)//分类
		AfxMessageBox("分类样本时出错,请确定是否已经训练样本!");
		
	CListCtrl*  pList = (CListCtrl*)GetDlgItem(IDC_LIST1);
	pList->DeleteAllItems();

	CString str;
	for(int pp=0;pp<m_TestSamples.n;pp++)
	{	
		CString str2;
		str2.Format("TEST-%d",pp+1);

		if(m_TestSamples.pClass[pp] == 0)
			str = "EWS";
		else if(m_TestSamples.pClass[pp] == 1)
			str = "NB";
		else if(m_TestSamples.pClass[pp] == 2 )
			str = "BL";
		else if(m_TestSamples.pClass[pp] == 3)
			str =  "RMS";

		pList->InsertItem(pp,"");
		pList->SetItemText(pp,0,str2);
		pList->SetItemText(pp,1,str);
	}			
	return TRUE;
}

/*****************************************************/
/*功  能：训练
/*参  数：无
/*返回值：
/*****************************************************/
BOOL CDNAClassificationDlg::Training(double **ppSample,int* pClass,int n,int dim)
{
	ASSERT(m_pDNAClassify);
	m_pDNAClassify->Clear();
	
	m_pDNAClassify->SetNotifyStatusFunc(NotifyStatus);
	if(m_pDNAClassify->Training(ppSample,pClass,n,dim)==FALSE)//训练
	{		
		return FALSE;
	}
	return TRUE;
}
//分类
BOOL CDNAClassificationDlg::Classify(double **ppTestSample,int* pClass,int n,int dim)
{
	if(m_pDNAClassify==NULL)
		return FALSE;

	if(m_pDNAClassify->Classify(ppTestSample,pClass,n,dim)==FALSE)//分类
	{
		//AfxMessageBox("分类样本时出错,请确定是否已经训练样本!");
		return FALSE;
	}
	return TRUE;
}

BOOL CDNAClassificationDlg::ClearTrainSamples(TrainingSample& samples)
{
	if(samples.c <= 0||samples.n <=0)
		return FALSE;

	if(samples.ppSamples)
	{
		for(int i = 0;i<samples.n;i++)
		{
			delete samples.ppSamples[i];
			samples.ppSamples[i] = NULL;
		}
		delete samples.ppSamples;
		samples.ppSamples = NULL;
	}
	if(samples.pClass)
	{
		delete samples.pClass;
		samples.pClass = NULL;
	}
	if(samples.pExludeSample)
	{
		delete samples.pExludeSample;
		samples.pExludeSample = NULL;
	}
	return TRUE;
}
BOOL CDNAClassificationDlg::ClearTestSamples(TestSample& samples)
{
	if(samples.c <= 0||samples.n <=0)
		return FALSE;

	if(samples.ppTestSamples)
	{
		for(int i = 0;i<samples.n;i++)
		{
			delete[] samples.ppTestSamples[i];
			samples.ppTestSamples[i] = NULL;
		}
		delete[] samples.ppTestSamples;
		samples.ppTestSamples = NULL;
	}
	if(samples.pClass)
	{
		delete samples.pClass;
		samples.pClass = NULL;
	}	
	return TRUE;
}

void CDNAClassificationDlg::OnDestroy() 
{
	CDialog::OnDestroy();

	if(m_pDNAClassify)
		delete m_pDNAClassify;	

	ClearTrainSamples(m_TrainSamples);
	ClearTestSamples(m_TestSamples);
}

//错误率分析
UINT CDNAClassificationDlg::AnalyseProc(LPVOID  pParam)
{
	CDNAClassificationDlg*  pDlg = (CDNAClassificationDlg*)pParam;
	ASSERT(pDlg);

	pDlg->m_dwTime = GetTickCount();

	//读取样本
	pDlg->ReadTrainSamples();	
	
	int nErro = 0;

	pDlg->AllocTest(pDlg->m_TestSamples,1,pDlg->m_TrainSamples.c);	

	pDlg->m_TestSamples.pClass[0] = -1;	

	pDlg->m_TrainSamples.nExclude = 1;

	CString strSamp;
	CListCtrl* pList = (CListCtrl*)pDlg->GetDlgItem(IDC_LIST2);	
	for(int i = 0;i<pDlg->m_TrainSamples.n;i++)
	{
		int pre = i-1;
		if(pre>=0)
			pDlg->m_TrainSamples.pExludeSample[pre] = -1;
		pDlg->m_TrainSamples.pExludeSample[i] = 1;

		pDlg->Training();		
				
		for(int j = 0;j<pDlg->m_TrainSamples.c;j++)
		{
			pDlg->m_TestSamples.ppTestSamples[0][j] = pDlg->m_TrainSamples.ppSamples[i][j];
		}

		//分类
		pDlg->Classify(pDlg->m_TestSamples.ppTestSamples,
			pDlg->m_TestSamples.pClass,1,pDlg->m_TrainSamples.c);
						
		strSamp.Format("样本%d",i+1);
		pList->InsertItem(i,"");
		pList->SetItemText(i,0,strSamp);

		if(pDlg->m_TrainSamples.pClass[i] == 0)
			strSamp = "EWS";
		else if(pDlg->m_TrainSamples.pClass[i] == 1)
			strSamp = "NB";			
		else if(pDlg->m_TrainSamples.pClass[i] == 2)
			strSamp = "NL";			
		else strSamp = "RMS";
		pList->SetItemText(i,1,strSamp);

		if(pDlg->m_TestSamples.pClass[0] == 0)
			strSamp = "EWS";
		else if(pDlg->m_TestSamples.pClass[0] == 1)
			strSamp = "NB";			
		else if(pDlg->m_TestSamples.pClass[0] == 2)
			strSamp = "NL";			
		else strSamp = "RMS";		
		pList->SetItemText(i,2,strSamp);

		if(pDlg->m_TestSamples.pClass[0] != pDlg->m_TrainSamples.pClass[i])
		{
			nErro++;
			strSamp = "错误";
		}
		else strSamp = "正确";

		pList->SetItemText(i,3,strSamp);
	}	
	pDlg->m_TrainSamples.pExludeSample[pDlg->m_TrainSamples.n-1] = -1;
	pDlg->m_TrainSamples.nExclude = 0;		

	pDlg->m_nTotalSam = pDlg->m_TrainSamples.n;
	pDlg->m_nErro = nErro;
	pDlg->m_dRate =(double) (pDlg->m_nTotalSam-nErro)/pDlg->m_nTotalSam;
	pDlg->m_dCost = (double)(GetTickCount()-pDlg->m_dwTime)/1000.0;

	//释放分配的内存
	pDlg->ClearTestSamples(pDlg->m_TestSamples);

	pDlg->SendMessage(WM_COMMAND,MAKEWPARAM(0,WM_UPDATEDATA));

	return 0;
}

//分类
UINT CDNAClassificationDlg::ClassifyProc(LPVOID  pParam)
{
	CDNAClassificationDlg*  pDlg = (CDNAClassificationDlg*)pParam;
	ASSERT(pDlg);
	
	pDlg->m_dwTime = GetTickCount();

	//读取训练样本
	pDlg->ReadTrainSamples();
	
	//训练
	pDlg->Training();
	
	//读测试样本
	pDlg->ReadTestSamples();

	//分类
	pDlg->Classify();//分类

	pDlg->m_TotalTest = pDlg->m_TestSamples.n;	
	
	pDlg->m_dTestCost = (double)(GetTickCount()-pDlg->m_dwTime)/1000.0;

	pDlg->SendMessage(WM_COMMAND,MAKEWPARAM(0,WM_UPDATEDATA));
	
	return 0;
}


BOOL CDNAClassificationDlg::OnCommand(WPARAM wParam, LPARAM lParam) 
{
	int uCommand = HIWORD(wParam);
	if(WM_UPDATEDATA == uCommand)
	{
		GetDlgItem(IDC_BUTTON_ANALYSE)->EnableWindow(TRUE);
		GetDlgItem(IDC_BUTTON_STOPANALYSE)->EnableWindow(FALSE);
		GetDlgItem(IDC_BUTTON_CLASSIFY)->EnableWindow(TRUE);
		GetDlgItem(IDC_BUTTON_STOPCLASSIFY)->EnableWindow(FALSE);

		GetDlgItem(IDC_RADIO_NEAR)->EnableWindow(TRUE);
		GetDlgItem(IDC_RADIO_BP)->EnableWindow(TRUE);
		GetDlgItem(IDC_RADIO_PNN)->EnableWindow(TRUE);
//		GetDlgItem(IDC_RADIO_FISHER)->EnableWindow(TRUE);

		m_ProgAnalyse.SetPos(0);
		UpdateData(FALSE);
		m_hThread = NULL;
	}
	
	return CDialog::OnCommand(wParam, lParam);
}

void CDNAClassificationDlg::OnButtonClassify() 
{
	UpdateData(TRUE);

	if(m_ClassifyMethod ==-1)
	{
		AfxMessageBox("请选择一种分类算法");
		return ;
	}

	CListCtrl* pList = (CListCtrl*)GetDlgItem(IDC_LIST1);
	pList->DeleteAllItems();

	m_dTestCost = 0.0;
	m_TotalTest = 0;
	UpdateData(FALSE);

	GetDlgItem(IDC_BUTTON_ANALYSE)->EnableWindow(FALSE);
	GetDlgItem(IDC_BUTTON_STOPANALYSE)->EnableWindow(FALSE);
	GetDlgItem(IDC_BUTTON_CLASSIFY)->EnableWindow(FALSE);
	GetDlgItem(IDC_BUTTON_STOPCLASSIFY)->EnableWindow(TRUE);

	GetDlgItem(IDC_RADIO_NEAR)->EnableWindow(FALSE);
	GetDlgItem(IDC_RADIO_BP)->EnableWindow(FALSE);
	GetDlgItem(IDC_RADIO_PNN)->EnableWindow(FALSE);
//	GetDlgItem(IDC_RADIO_FISHER)->EnableWindow(FALSE);		

	m_nMode = 1;
	CWinThread* pWin = AfxBeginThread(ClassifyProc,this);
	m_hThread = pWin->m_hThread;
}
void CDNAClassificationDlg::OnButtonStopclassify() 
{	
	if(m_hThread)
	{
		if(TerminateThread(m_hThread,0)==FALSE)
		{
			AfxMessageBox("停止失败！");
		}
		else 
		{
			GetDlgItem(IDC_BUTTON_ANALYSE)->EnableWindow(TRUE);
			GetDlgItem(IDC_BUTTON_STOPANALYSE)->EnableWindow(FALSE);
			GetDlgItem(IDC_BUTTON_CLASSIFY)->EnableWindow(TRUE);
			GetDlgItem(IDC_BUTTON_STOPCLASSIFY)->EnableWindow(FALSE);

			GetDlgItem(IDC_RADIO_NEAR)->EnableWindow(TRUE);
			GetDlgItem(IDC_RADIO_BP)->EnableWindow(TRUE);
			GetDlgItem(IDC_RADIO_PNN)->EnableWindow(TRUE);
//			GetDlgItem(IDC_RADIO_FISHER)->EnableWindow(TRUE);		

			CListCtrl* pList = (CListCtrl*)GetDlgItem(IDC_LIST1);
			pList->DeleteAllItems();			
		}
		m_hThread = NULL;
	}
}


LRESULT CDNAClassificationDlg::NotifyStatus(LPVOID lpParam)
{	
	if(lpParam==NULL)
		return 0;
	CDNAClassificationDlg* pDlg = (CDNAClassificationDlg*)AfxGetApp()->GetMainWnd();
	if(pDlg->m_nMode == 0)
	{
		double*pdRate = (double*)lpParam;
		
		int pos = (int)(100.0*(*pdRate));
		pDlg->m_ProgAnalyse.SetPos(pos);
	}
	return 0;
}

void CDNAClassificationDlg::OnOK() 
{
	if(m_hThread)
	{
		if(TerminateThread(m_hThread,0)==FALSE)
		{
			AfxMessageBox("停止线程失败！");
		}
		m_hThread = NULL;
	}
	CDialog::OnOK();
}



void CDNAClassificationDlg::OnRadioNear() 
{
	if(m_pDNAClassify!=NULL&&m_pDNAClassify->GetName() != "K-Nearest")
	{
		delete m_pDNAClassify;		
		m_pDNAClassify = NULL;
	}
	if(m_pDNAClassify==NULL)
		m_pDNAClassify = new CNearest();

	CNearestParamDlg dlg;
	dlg.m_nK = ((CNearest*)m_pDNAClassify)->GetKParam();
	if(dlg.DoModal() == IDOK)
	{
		((CNearest*)m_pDNAClassify)->SetKParam(dlg.m_nK);
	}
	
}

void CDNAClassificationDlg::OnRadioBp() 
{
	if(m_pDNAClassify!=NULL&&m_pDNAClassify->GetName() != "BP")
	{
		delete m_pDNAClassify;
		m_pDNAClassify = NULL;		
	}
	if(m_pDNAClassify==NULL)
		m_pDNAClassify = new DNANNet();
}
void CDNAClassificationDlg::OnRadioPnn() 
{	
	if(m_pDNAClassify!=NULL&&m_pDNAClassify->GetName() != "PNN")
	{
		delete m_pDNAClassify;
		m_pDNAClassify = NULL;
	}	
	if(m_pDNAClassify==NULL)
		m_pDNAClassify = new CPNN();
	
	CPNNParamDlg dlg;
	dlg.m_dWidth = ((CPNN*)m_pDNAClassify)->GetParzenWidth();
	if(dlg.DoModal() == IDOK)
	{
		((CPNN*)m_pDNAClassify)->SetParzenWidth(dlg.m_dWidth);
	}
}



CString CDNAClassificationDlg::GetPath()
{
	TCHAR szAppPath[_MAX_PATH];
	GetModuleFileName(NULL, szAppPath, _MAX_PATH);
	CString str = szAppPath;
	int index = str.ReverseFind('\\');
	str = str.Left(index);
	str+="\\";
	return str;
}