neuralnetworkplatform.cpp

使用神经网络开发包实现图形化的神经网络模拟

			mousePosTemp=CPoint(mousePosTemp.x,mousePosTemp.y+LINESIZE);
		}
		if(point.y<=mousePosTemp.y-LINESIZE)
		{
			linePosTemp=CPoint(linePosTemp.x,linePosTemp.y-LINESIZE);
			pDC->BitBlt(linePosTemp.x,linePosTemp.y,LINESIZE,LINESIZE,&dcCompatible,0,0,SRCCOPY);
			(*iter).outputLine[btnPosType-1].outputPoint.push_back(CPoint(linePosTemp.x,linePosTemp.y));	
			mousePosTemp=CPoint(mousePosTemp.x,mousePosTemp.y-LINESIZE);
		}
	}
}

void NeuralNetworkPlatform::neuronReleased(CDC *pDC, CPoint point,CRect rect)
{
	int i=0;
	NeuralNode neuralTemp;
	vector<NeuralNode>::iterator it;
	
	CBitmap bmp;
	CDC dcCompatible;
	if(-1==btnPosType)
	{	//=============鼠标位置为神经元中心=============
		btnPosType=0;
		neuralTemp=(*iter);
		//=====重新计算中心点坐标==========
		neuralTemp.centerPos+=CPoint(neuralPosTemp.x-neuralTemp.nodePos.x,neuralPosTemp.y-neuralTemp.nodePos.y);
		//=====重新计算边缘节点的坐标=======
		for(i=0;i<EDGENUM;i++)
		{
			neuralTemp.edgeNodePos[i]+=CPoint(neuralPosTemp.x-neuralTemp.nodePos.x,neuralPosTemp.y-neuralTemp.nodePos.y);
		}
		neuralTemp.nodePos=neuralPosTemp;
		neuralContainer.erase(iter);
		if(neuralContainer.empty())
		{
			neuralContainer.push_back(neuralTemp);
			return;
		}
		for(it=neuralContainer.end()-1;it!=neuralContainer.begin()-1;it--)
		{
			if(neuralTemp.nodePos.x>(*it).nodePos.x||(neuralTemp.nodePos.x==(*it).nodePos.x)&&(neuralTemp.nodePos.y>=(*it).nodePos.y))
			{
				neuralContainer.insert(it+1,neuralTemp);
				return;
			}
		}
		neuralContainer.insert(neuralContainer.begin(),neuralTemp);
	}
	if(btnPosType>=1 && btnPosType<=12)		
	{//==============鼠标位置为边缘节点===============
		for(it=neuralContainer.begin();it!=neuralContainer.end();it++)
		{
			for(i=0;i<EDGENUM;i++)
			{
				if((*it).edgeType[i]==0 && (*it).edgeNodePos[i].PtInRect(point))
				{
					//==========将边缘节点类型设置为输入=======
					(*it).edgeType[i]=-1;
					(*it).inputNeuronIndex[i]=(*iter).totalIndex;
					(*iter).outputLine[btnPosType-1].outputNeuronIndex=(*it).totalIndex;
					bmp.LoadBitmap(IDB_BMP_LINEEND);
					dcCompatible.CreateCompatibleDC(pDC);
					dcCompatible.SelectObject(&bmp);
					linePosTemp=CPoint((*it).edgeNodePos[i].TopLeft().x,(*it).edgeNodePos[i].TopLeft().y);
					pDC->BitBlt(linePosTemp.x,linePosTemp.y,LINESIZE,LINESIZE,&dcCompatible,0,0,SRCCOPY);
					//==========释放绘图资源========
					dcCompatible.DeleteDC();
					bmp.DeleteObject();
					//==========恢复btnPosType原始值===========
					btnPosType=0;
				}
			}
		}
		//==================如果连线不成功，则删除连线===================
		if(btnPosType!=0)
		{
			//=============删除输出路线记录===========
			(*iter).outputLine[btnPosType-1].outputPoint.clear();
			//============修改边缘节点类型============
			(*iter).edgeType[btnPosType-1]=0;
			//============重绘=======================
			neuralRedraw(pDC,rect);
			//=============重置btnPosType值===========
			btnPosType=0;	
		}
	}
}

void NeuralNetworkPlatform::neuronRSelected(CPoint point,CDC *pDC,CRect rect)
{
	for(vector<NeuralNode>::iterator it=neuralContainer.begin();it!=neuralContainer.end();it++)
	{
		//==============右键点中神经元中心==================
		if((*it).centerPos.PtInRect(point))
		{	
			iter=it;
			CDlgNeuron dlgNeuron;
			dlgNeuron.setFunction(0);
			dlgNeuron.setCDC(pDC);
			dlgNeuron.setRect(rect);
			dlgNeuron.DoModal();
			return;
		}	
		//===============右键点中神经元边缘结点==============
		for(int i=0;i<EDGENUM;i++)
		{  
			if((*it).edgeType[i]==1 && (*it).edgeNodePos[i].PtInRect(point))
			{
				iter=it;
				btnPosType=i+1;
				CDlgLine dlgLine;
				dlgLine.setCDC(pDC);
				dlgLine.setRect(rect);
				dlgLine.DoModal();
				btnPosType=0;
			}
		}
	}
}

void NeuralNetworkPlatform::setCurrentBias(real newBias)
{
	(*iter).setBias(newBias);
}

void NeuralNetworkPlatform::setCurrectFunction(ActivationFunction newFunction)
{
	(*iter).setActivationFunction(newFunction);
}

void NeuralNetworkPlatform::setCurrentWeight(real newWeight)
{
	(*iter).setWeight(newWeight,btnPosType);
}

int NeuralNetworkPlatform::getLayerNum()
{
	return layerNum;
}

void NeuralNetworkPlatform::neuralRedraw(CDC *pDC,CRect rect)
{
	//================重绘背景=======================
	CBitmap bitmap;
	bitmap.LoadBitmap(IDB_BMP_BACK);

	CDC dcCompatible;
	dcCompatible.CreateCompatibleDC(pDC);
	dcCompatible.SelectObject(&bitmap);

	pDC->BitBlt(0,0,rect.Width(),rect.Height(),&dcCompatible,0,0,SRCCOPY);
	//===============重绘神经元======================
	CBitmap bmpNeuron,bmpLineBegin,bmpLineEnd,bmpLine;
	CDC dcCompatibleNeuron,dcLineBegin,dcLineEnd,dcLine;
		
	bmpNeuron.LoadBitmap(IDB_BMP_NEURON);
	bmpLineBegin.LoadBitmap(IDB_BMP_LINEBEGIN);
	bmpLineEnd.LoadBitmap(IDB_BMP_LINEEND);
	bmpLine.LoadBitmap(IDB_BMP_LINE);

	dcCompatibleNeuron.CreateCompatibleDC(pDC);
	dcLineBegin.CreateCompatibleDC(pDC);
	dcLineEnd.CreateCompatibleDC(pDC);
	dcLine.CreateCompatibleDC(pDC);

	dcCompatibleNeuron.SelectObject(&bmpNeuron);
	dcLineBegin.SelectObject(&bmpLineBegin);
	dcLineEnd.SelectObject(&bmpLineEnd);
	dcLine.SelectObject(&bmpLine);

	for(vector<NeuralNode>::iterator it=neuralContainer.begin();it!=neuralContainer.end();it++)
	{
		pDC->BitBlt((*it).nodePos.x,(*it).nodePos.y,NEURALSIZE,NEURALSIZE,&dcCompatibleNeuron,0,0,SRCCOPY);
		//==========重绘连线============
		for(int i=0;i<EDGENUM;i++)
		{
			for(vector<CPoint>::iterator iter=(*it).outputLine[i].outputPoint.begin();iter!=(*it).outputLine[i].outputPoint.end();iter++)
			{
				pDC->BitBlt((*iter).x,(*iter).y,LINESIZE,LINESIZE,&dcLine,0,0,SRCCOPY);
			}
			if((*it).edgeType[i]==1)
			{
				pDC->BitBlt((*it).edgeNodePos[i].TopLeft().x,(*it).edgeNodePos[i].TopLeft().y,LINESIZE,LINESIZE,&dcLineBegin,0,0,SRCCOPY);
			}
			if((*it).edgeType[i]==-1)
			{				
				pDC->BitBlt((*it).edgeNodePos[i].TopLeft().x,(*it).edgeNodePos[i].TopLeft().y,LINESIZE,LINESIZE,&dcLineEnd,0,0,SRCCOPY);
			}
		}
	}
	dcCompatibleNeuron.DeleteDC();
	dcLineBegin.DeleteDC();
	dcLineEnd.DeleteDC();
	dcLine.DeleteDC();
}

void NeuralNetworkPlatform::Serialize(CArchive &ar)
{
	//==============保存==================
	if(ar.IsStoring())
	{
		ar<<layerNeurons.size()<<neuralContainer.size()<<layerNum<<neuralNum;
		for(vector<int>::iterator it=layerNeurons.begin();it!=layerNeurons.end();it++)
		{
			ar<<(*it);
		}
		for(vector<NeuralNode>::iterator iter=neuralContainer.begin();iter!=neuralContainer.end();iter++)
		{
			(*iter).Serialize(ar);
		}
	}
	//================读出================
	else
	{
		int intTemp=0;
		NeuralNode nodeTemp=NeuralNode();
		int layerNeuronsSize=0;
		int neuralContainerSize=0;
		ar>>layerNeuronsSize>>neuralContainerSize>>layerNum<<neuralNum;
		for(int i=0;i<layerNeuronsSize;i++)
		{
			ar>>intTemp;
			layerNeurons.push_back(intTemp);
		}
		for(int j=0;j<neuralContainerSize;j++)
		{
			nodeTemp.Serialize(ar);
			neuralContainer.push_back(nodeTemp);
		}
	}
}

vector<int>& NeuralNetworkPlatform::getLayerNeurons()
{
	return layerNeurons;
}

vector<NeuralNode>& NeuralNetworkPlatform::getNeuralContainer()
{
	return neuralContainer;
}

void NeuralNetworkPlatform::networkResult(CString inputFileName, CString outputFileName)
{
	vector<real> vectorInput,vectorOutput;
	CString strBuf,strTemp,outputTemp,strOutput;
	int posOld=0,posNew=0;

	int inputNum=*(layerNeurons.begin());
	int outputNum=*(layerNeurons.end()-1);

	CFile fileTest,fileResult;
	fileTest.Open(inputFileName,CFile::modeRead);
	fileResult.Open(outputFileName,CFile::modeCreate|CFile::modeWrite);

	char* charBuf=new char[fileTest.GetLength()];
	UINT byteNum=fileTest.Read(charBuf,fileTest.GetLength());
	charBuf[byteNum]=NULL;

	strBuf=charBuf;
	
	while(posNew!=strBuf.GetLength()-1)
	{	//===========input==================
		for(int i=0;i<inputNum-1;i++)
		{
			posNew=strBuf.Find(" ",posOld);
			strTemp=strBuf.Mid(posOld,posNew-posOld);
			posOld=posNew+1;
			vectorInput.push_back(atof(strTemp));
		}
		posNew=strBuf.Find("\n",posOld);
		strTemp=strBuf.Mid(posOld,posNew-posOld);
		posOld=posNew+1;
		vectorInput.push_back(atof(strTemp));
		//======================获得输出=================
		vectorOutput=multiNet->getOutput(vectorInput);

		for(vector<real>::iterator it=vectorOutput.begin();it!=vectorOutput.end();it++)
		{
			outputTemp.Format("%f",(*it));
			strOutput=strOutput+outputTemp+" ";
		}
		strOutput+="\r\n";
		char *charOutput=new char[strOutput.GetLength()];
		charOutput=strOutput.GetBuffer(strOutput.GetLength());
		strOutput.ReleaseBuffer();
		fileResult.Write(charOutput,strOutput.GetLength());
		//==========清空输出==============
		strOutput="";
		
		vectorInput.clear();
		vectorOutput.clear();
	}
	fileTest.Close();
	fileResult.Close();
	AfxMessageBox("实验结果已存储到文件中!");
}

bool NeuralNetworkPlatform::deleteNeuron(CDC *pDC,CRect rect)
{
	for(int i=0;i<EDGENUM;i++)
	{
		if((*iter).edgeType[i]!=0)
		{
			return false;
		}
	}
	neuralContainer.erase(iter);
	neuralRedraw(pDC,rect);
	return true;
}

bool NeuralNetworkPlatform::deleteLine(CDC *pDC, CRect rect)
{
	CString strTemp;
	strTemp.Format("%d",btnPosType);
	AfxMessageBox(strTemp);
	(*iter).outputLine[btnPosType-1].outputPoint.clear();
	(*iter).edgeType[btnPosType-1]=0;
	for(vector<NeuralNode>::iterator it=neuralContainer.begin();it!=neuralContainer.end();it++)
	{
		if((*iter).outputLine[btnPosType-1].outputNeuronIndex == (*it).totalIndex )
		{
			for(int i=0;i<EDGENUM;i++)
			{
				if((*it).inputNeuronIndex[i]==(*iter).totalIndex)
				{
					(*it).edgeType[i]=0;
				}
			}
		}
	}
	neuralRedraw(pDC,rect);
	return true;
}

bool NeuralNetworkPlatform::neuralCheckPosition()
{
	for(vector<NeuralNode>::iterator it=neuralContainer.begin();it!=neuralContainer.end();it++)
	{
		for(vector<NeuralNode>::iterator iter=neuralContainer.begin();iter!=neuralContainer.end();iter++)
		{
			for(int i=0;i<EDGENUM;i++)
			{
				for(int j=0;j<EDGENUM;j++)
				{
					if((*it).outputLine[i].outputNeuronIndex!=-1 && (*it).outputLine[i].outputNeuronIndex==(*iter).outputLine[j].outputNeuronIndex && (*it).nodePos.x!=(*iter).nodePos.x)
					{
						//CString strTemp;
						//strTemp.Format("%d[%d]%d:x:%d,%d[%d]%d:x:%d",(*it).totalIndex,i,(*it).outputLine[i].outputNeuronIndex,(*it).nodePos.x,
						//	(*iter).totalIndex,j,(*iter).outputLine[j].outputNeuronIndex,(*iter).nodePos.x);
						//AfxMessageBox(strTemp);
						return false;
					}
				}
			}
		}
	}
	return true;
}