ccontroller.cpp

一种动态环境下的基于神经网络的机器人路径搜索

#include "CController.h"


//these hold the geometry of the sweepers and the mines
const int	 NumSweeperVerts = 16;
const SPoint sweeper[NumSweeperVerts] = {SPoint(-1, -1),
                                         SPoint(-1, 1),
                                         SPoint(-0.5, 1),
                                         SPoint(-0.5, -1),

                                         SPoint(0.5, -1),
                                         SPoint(1, -1),
                                         SPoint(1, 1),
                                         SPoint(0.5, 1),
                                         
                                         SPoint(-0.5, -0.5),
                                         SPoint(0.5, -0.5),

                                         SPoint(-0.5, 0.5),
                                         SPoint(-0.25, 0.5),
                                         SPoint(-0.25, 1.75),
                                         SPoint(0.25, 1.75),
                                         SPoint(0.25, 0.5),
                                         SPoint(0.5, 0.5)};


const int NumObjectVerts = 54;
const SPoint objects[NumObjectVerts] = {SPoint(20, 15),
                                        SPoint(600,15),
                                        SPoint(600,15),
                                        SPoint(600,600),
										SPoint(600,600),
                                        SPoint(20,600),
                                        SPoint(20,600),
                                        SPoint(20,15),

                                        SPoint(100,100),
										SPoint(250,100),
                                        SPoint(250,100),
                                        SPoint(100,250),
                                        SPoint(100,250),
                                        SPoint(100,100),
      
                                        SPoint(30,350),
                                        SPoint(270,350),
                                        SPoint(270,350),
                                        SPoint(270,500),
                                        SPoint(270,500),
                                        SPoint(30,500),
                                        SPoint(30,500),
                                        SPoint(30,350),

                                        SPoint(300,30),
                                        SPoint(400,30),
                                        SPoint(400,30),
                                        SPoint(510,280),
                                        SPoint(510,280),
										SPoint(410,280),
										SPoint(410,280),
										SPoint(300,30),

										SPoint(410, 320),
										SPoint(540, 420),
										SPoint(540, 420),
										SPoint(350, 500),
										SPoint(350, 500),
										SPoint(410, 320),

										SPoint(350,280),
										SPoint(400,280),
										SPoint(400,280),
										SPoint(400,330),
                                        SPoint(400,330),
                                        SPoint(350,330),
                                        SPoint(350,330),
										SPoint(350,280),

										SPoint(300,180),
										SPoint(350,180),
										SPoint(350,180),
                                        SPoint(350,230),
                                        SPoint(350,230),
                                        SPoint(300,230),
										SPoint(300,230),
										SPoint(300,180),

								};


//---------------------------------------constructor---------------------
//
//	initilaize the sweepers, their brains and the GA factory
//
//-----------------------------------------------------------------------
CController::CController(HWND hwndMain): m_NumSweepers(CParams::iNumSweepers), 
										                     m_pGA(NULL),
										                     m_bFastRender(false),
										                     m_iTicks(0),
										                     m_hwndMain(hwndMain),
										                     m_iGenerations(0),
															 dk(0),
                                         cxClient(CParams::WindowWidth),
                                         cyClient(CParams::WindowHeight)
                                         
{
	//let's create the mine sweepers
	for (int i=0; i<m_NumSweepers; ++i)
	{
		m_vecSweepers.push_back(CMinesweeper());
	}

	//get the total number of weights used in the sweepers
	//NN so we can initialise the GA
	m_NumWeightsInNN = m_vecSweepers[0].GetNumberOfWeights();

  //calculate the neuron placement in the weight vector
  vector<int> SplitPoints = m_vecSweepers[0].CalculateSplitPoints();

	//initialize the Genetic Algorithm class
	m_pGA = new CGenAlg(m_NumSweepers,
                      CParams::dMutationRate,
	                    CParams::dCrossoverRate,
	                    m_NumWeightsInNN,
                      SplitPoints);

	//Get the weights from the GA and insert into the sweepers brains
	m_vecThePopulation = m_pGA->GetChromos();

	for (i=0; i<m_NumSweepers; i++)
  {
		m_vecSweepers[i].PutWeights(m_vecThePopulation[i].vecWeights);
  }


	//create pens for the graph drawing
	m_BluePen        = CreatePen(PS_SOLID, 1, RGB(0, 0, 255));
	m_RedPen         = CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
	m_GreenPen       = CreatePen(PS_SOLID, 1, RGB(0, 255, 0));
  m_GreyPenDotted  = CreatePen(PS_DOT, 1, RGB(200, 200, 200));
  m_RedPenDotted   = CreatePen(PS_DOT, 1, RGB(250, 200, 200));

	m_OldPen	= NULL;

  //and the brushes
  m_BlueBrush = CreateSolidBrush(RGB(0,0,244));
  m_RedBrush = CreateSolidBrush(RGB(150,0,0));

	//fill the vertex buffers
	for (i=0; i<NumSweeperVerts; ++i)
	{
		m_SweeperVB.push_back(sweeper[i]);
	}

  for (i=0; i<NumObjectVerts; ++i)
  {
    m_ObjectsVB.push_back(objects[i]);
  }
}

//--------------------------------------destructor-------------------------------------
//
//--------------------------------------------------------------------------------------
CController::~CController()
{
	if(m_pGA)
  {
    delete		m_pGA;
  }

	DeleteObject(m_BluePen);
	DeleteObject(m_RedPen);
	DeleteObject(m_GreenPen);
	DeleteObject(m_OldPen);
  DeleteObject(m_GreyPenDotted);
  DeleteObject(m_RedPenDotted);
  DeleteObject(m_BlueBrush);
  DeleteObject(m_RedBrush);
}


//---------------------WorldTransform--------------------------------
//
//	sets up the translation matrices for the mines and applies the
//	world transform to each vertex in the vertex buffer passed to this
//	method.
//-------------------------------------------------------------------
void CController::WorldTransform(vector<SPoint> &VBuffer,
                                 SVector2D      vPos,
                                 double         rotation,
                                 double         scale)
{
	//create the world transformation matrix
	C2DMatrix matTransform;
	
	//scale
	matTransform.Scale(scale, scale);

   	//rotate
	matTransform.Rotate(rotation);
	
	//translate
	matTransform.Translate(vPos.x, vPos.y);


	//transform the ships vertices
	matTransform.TransformSPoints(VBuffer);
}


//-------------------------------------Update---------------------------------------
//
//	This is the main workhorse. The entire simulation is controlled from here.
//
//	The comments should explain what is going on adequately.
//--------------------------------------------------------------------------------------
bool CController::Update()
{
  //run the sweepers through NUM_TICKS amount of cycles. During this loop each
	//sweepers NN is constantly updated with the appropriate information from its 
	//surroundings. The output from the NN is obtained and the sweeper is moved. If
	//it encounters a mine its fitness is updated appropriately,
	if (m_iTicks++ < CParams::iNumTicks)
	{
		for (int i=0; i<m_NumSweepers; ++i)
		{
			//update the NN and position
			if (!m_vecSweepers[i].Update(m_ObjectsVB))
			{
				//error in processing the neural net
				MessageBox(m_hwndMain, "Wrong amount of NN inputs!", "Error", MB_OK);

				return false;
			}
		}
	}

	//**We have completed another generation.

	//Time to run the GA and update the sweepers with their new NNs
	else
	{
   for (int swp=0; swp<m_vecSweepers.size(); ++swp)
    {
        //add up all the penalties and calculate a fitness score
        m_vecSweepers[swp].EndOfRunCalculations();

        //update the fitness score stored in the GA with this score
			  m_vecThePopulation[swp].dFitness = m_vecSweepers[swp].Fitness();
    }

		//update the stats to be used in our stat window
		m_vecAvFitness.push_back(fabs(m_pGA->AverageRawFitness()));
		m_vecBestFitness.push_back(fabs(m_pGA->BestRawFitness()));

		//increment the generation counter
		++m_iGenerations;

		//reset cycles
		m_iTicks = 0;

		//insert the sweepers chromosones into the GA factory and