simulatorview.cpp

基于vc 的环境下机器人自主避障的算法 图形处理 具有载物功能

			}

		}
	break;

	// creating holonomic robot
	case HOLONOMICROBOT:
		robot = new CRobotHolonomic(aux->x, aux->y, 0, DOCK, (short) pDoc->m_robots.GetSize(), "");
		robot->m_localMap = new CMapPath(pDoc->m_globalMap, FALSE);
		pDoc->AddRobot(robot);
	break;

	// creating nonholonomic robot
	case NONHOLONOMICROBOT:
		robot = new CRobotNonHolonomic(aux->x, aux->y, 0, DOCK, (short) pDoc->m_robots.GetSize(), "");
		robot->m_localMap = new CMapPath(pDoc->m_globalMap, FALSE);
		pDoc->AddRobot(robot);
	break;

	// creating labmate robot
	case LABMATEROBOT:
		robot = new CRobotLabmate(aux->x, aux->y, 0, DOCK, (short) pDoc->m_robots.GetSize(), "");
		robot->m_localMap = new CMapPath(pDoc->m_globalMap, TRUE);
		pDoc->AddRobot(robot);
	break;

	}

	Invalidate();

	CScrollView::OnLButtonDown(nFlags, point);
}

// mouse left button double click
void CSimulatorView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	CPoint *aux;

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	CClientDC dc(this);
	OnPrepareDC(&dc);
	aux = new CPoint(point);
	dc.DPtoLP(aux);

	// Finish polygon insertion
	ReleaseCapture();
	if ( polygon->FinishPointInsertion() ) {
		if (pDoc->m_selectedButton == POLYGONOBST) {
			CObstacle *obst = new CObstaclePolygon(polygon);
			pDoc->AddObstacle(obst);
		}
		else if (pDoc->m_selectedButton == POLYGONBOX) {
			pDoc->m_box = new CBoxPolygon(polygon);
		}
	}
	polygon->RemoveAllPoints();

	Invalidate();
	CScrollView::OnLButtonDblClk(nFlags, point);
}

// Mouse right button
void CSimulatorView::OnRButtonUp(UINT nFlags, CPoint point) 
{
	CPoint *aux;
	int i;

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	CClientDC dc(this);
	OnPrepareDC(&dc);
	aux = new CPoint(point);
	dc.DPtoLP(aux);
	m_clickPoint = (*aux);

	// Test if the click is over a robot
	pDoc->m_selectedRobot = -1;
	for(i=0; i<pDoc->m_robots.GetSize(); i++){
		CRobot *robot = pDoc->m_robots[i];
		if ( robot->m_rect.PtInRect(m_clickPoint) ) {
			pDoc->m_selectedRobot = i;
			break;
		}
	}

	if (pDoc->m_selectedRobot != -1) {
		// Call robot menu
		CPoint p = point;
		ClientToScreen(&p);
		m_contextMenu->GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN + TPM_RIGHTBUTTON, p.x, p.y, this);
	}
	else {
		// Call popup menu
		CPoint p = point;
		ClientToScreen(&p);
		m_contextMenu->GetSubMenu(1)->TrackPopupMenu(TPM_LEFTALIGN + TPM_RIGHTBUTTON, p.x, p.y, this);
	}

	CScrollView::OnRButtonUp(nFlags, point);
}

// Mouse move
void CSimulatorView::OnMouseMove(UINT nFlags, CPoint point) 
{
	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	// select cursor
	if (pDoc->m_selectedButton == SELECT)
		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
	else if (pDoc->m_selectedButton == HOLONOMICROBOT)
		SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROBOTHOLONOMIC));
	else if (pDoc->m_selectedButton == NONHOLONOMICROBOT)
		SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROBOTNONHOLONOMIC));
	else if (pDoc->m_selectedButton == LABMATEROBOT)
		SetCursor(AfxGetApp()->LoadCursor(IDC_CURSORROBOTLABMATE));
	else	
		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS));

	// draw polygn construction lines
	if ( ( (pDoc->m_selectedButton == POLYGONOBST) || (pDoc->m_selectedButton == POLYGONBOX) ) ) {
		CClientDC dc(this);
		OnPrepareDC(&dc);
		CPoint *aux;
		aux = new CPoint(point);
		dc.DPtoLP(aux);

		polygon->Redraw(*aux, &dc);
	}

	CScrollView::OnMouseMove(nFlags, point);
}

// keybord events
void CSimulatorView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

//	CSingleLock sLock(&(pDoc->m_mutex));

	if ( (nChar == VK_DELETE) && (pDoc->m_selectedObst != -1) ) {
//		sLock.Lock();

		pDoc->m_globalMap->m_obstacles[pDoc->m_selectedObst]->m_erased = TRUE;
		pDoc->m_globalMap->m_obstacles[pDoc->m_selectedObst]->m_visited = FALSE;
		pDoc->m_selectedObst = -1;

		pDoc->m_globalMap->ComputeMap();
		pDoc->m_globalMap->ComputePath();

//		sLock.Unlock();

		if (pDoc->m_globalMap->m_isComputed)
			pDoc->m_mapView.Invalidate();

		m_trackerArray.RemoveAll();
		Invalidate();
	}

	if ( (nChar == VK_DELETE) && (pDoc->m_selectedRobot != -1) ) {
		OnDeleteRobot();
		m_trackerArray.RemoveAll();
		Invalidate();
	}

	if ( (nChar == VK_ESCAPE) && (pDoc->m_selectedObst != -1) ) {
		pDoc->m_selectedObst = -1;
		m_trackerArray.RemoveAll();
		Invalidate();
	}

	if ( (pDoc->m_selectedButton == POLYGONOBST) && (nChar == VK_ESCAPE) ){
		ReleaseCapture();
		polygon->RemoveAllPoints();
		Invalidate();
	}



	CScrollView::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CSimulatorView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	if (pDoc->m_selectedObst != -1) {
		pDoc->m_selectedObst = -1;
		Invalidate();
	}
	
	CScrollView::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CSimulatorView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	if (pDoc->m_selectedObst != -1) {
		pDoc->m_selectedObst = -1;
		Invalidate();
	}
	
	CScrollView::OnVScroll(nSBCode, nPos, pScrollBar);
}

//------------------------------------------------------------------
// Control and Data Messages
//------------------------------------------------------------------

// broadcast data mesage
LRESULT CSimulatorView::OnDataMsg(WPARAM wParam, LPARAM lParam)
{
	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	for(int i=0; i<pDoc->m_robots.GetSize(); i++){
		pDoc->m_robots[i]->SendMessage(WM_DATAMSG, wParam, lParam);
	}

	return 0L;
}



// broadcast control mesage
LRESULT CSimulatorView::OnControlMsg(WPARAM wParam, LPARAM lParam)
{
	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	for(int i=0; i<pDoc->m_robots.GetSize(); i++)
		pDoc->m_robots[i]->SendMessage(WM_CONTROLMSG, wParam, lParam);

	return 0L;
}


//---------------------------------------------------------------------------
// Messages to Create and Open windows
//---------------------------------------------------------------------------
void CSimulatorView::OnRobotInfo() 
{

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	m_info.ShowWindow(SW_SHOW);
	m_info.BringWindowToTop();
}


void CSimulatorView::OnCreateMap() 
{
	int i;

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

//	CSingleLock sLock(&(pDoc->m_mutex));
//	sLock.Lock();

	pDoc->m_globalMap->ComputeMap();
	pDoc->m_globalMap->ComputePath();

	if (pDoc->m_globalMap->m_isComputed) {
		pDoc->m_mapView.m_mapPath = pDoc->m_globalMap;
		pDoc->m_mapView.ShowWindow(SW_SHOW);
	}

	for(i=0; i<pDoc->m_robots.GetSize(); i++){
		if (pDoc->m_robots[i]->m_localMap->m_isComputed) {
			pDoc->m_robots[i]->m_localView.m_mapPath = pDoc->m_robots[i]->m_localMap;
			pDoc->m_robots[i]->m_localView.ShowWindow(SW_SHOW);

		}
	}
	
//	sLock.Unlock();
}

void CSimulatorView::OnOpenPconst() 
{
	dlgConsts = new CDlgConstants("Constants", this);
	dlgConsts->Create();
	//dlgConsts->ShowWindow(SW_SHOW);
	dlgConsts->BringWindowToTop();
}


//----------------------------------------------------
// Right click menu messages
//----------------------------------------------------
void CSimulatorView::OnSetGoal() 
{
	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

//	CSingleLock sLock(&(pDoc->m_mutex));
//	sLock.Lock();

	
	// Changing the goal
	pDoc->m_globalMap->m_goalReal = m_clickPoint;
	pDoc->m_globalMap->ComputeMap();
	pDoc->m_globalMap->ComputePath();

	for(int i=0; i<pDoc->m_robots.GetSize(); i++){
		pDoc->m_robots[i]->m_localMap->m_goalReal = m_clickPoint;
		pDoc->m_robots[i]->m_localMap->m_originReal = CPoint(round(pDoc->m_robots[i]->m_x), round(pDoc->m_robots[i]->m_y));
		pDoc->m_robots[i]->m_localMap->ComputeMap();
		pDoc->m_robots[i]->m_localMap->ComputePath();
		if (pDoc->m_robots[i]->m_localMap->m_isComputed)
			pDoc->m_robots[i]->m_localView.Invalidate();
	}

//	sLock.Unlock();

	if (pDoc->m_globalMap->m_isComputed)
		pDoc->m_mapView.Invalidate();


	Invalidate();
}

void CSimulatorView::OnCreateHolonomic() 
{
	CRobotHolonomic *robot;

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	robot = new CRobotHolonomic(m_clickPoint.x, m_clickPoint.y, 0, DOCK, (short) pDoc->m_robots.GetSize(), "");
	robot->m_localMap = new CMapPath(pDoc->m_globalMap);
	pDoc->AddRobot(robot);

	Invalidate();

}

void CSimulatorView::OnCreateNonHolonomic() 
{
	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	CRobotNonHolonomic *robot;

	robot = new CRobotNonHolonomic(m_clickPoint.x, m_clickPoint.y, 0, DOCK, (short) pDoc->m_robots.GetSize(), "");
	robot->m_localMap = new CMapPath(pDoc->m_globalMap);
	pDoc->AddRobot(robot);

	Invalidate();
}

void CSimulatorView::OnSetStatus() 
{

}

void CSimulatorView::OnSetOrientation() 
{
	CRobot *robot;

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	robot = pDoc->m_robots[pDoc->m_selectedRobot];

	// Seting robot Orientation
	CDlgOrientation dlg;
	dlg.m_theta = round(robot->m_theta * 180 / PI);
	if (dlg.DoModal() == IDOK) {
		robot->SetOrientation(PI * dlg.m_theta / (double) 180);
		Invalidate();
	}
}

void CSimulatorView::OnDeleteRobot() 
{
	CRobot *robot;

	CSimulatorDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

//	CSingleLock sLock(&(pDoc->m_mutex));
//	sLock.Lock();

	robot = pDoc->m_robots[pDoc->m_selectedRobot];

	CControlMsg *controlMsg;
	controlMsg = new CControlMsg;
	controlMsg->m_code = DELETEROBOT;
	controlMsg->m_from = robot->m_id;
	controlMsg->m_extra = robot->m_numRobots - 1;
	controlMsg->m_to = 0;
	robot->SendControlMsg(controlMsg);
	
	robot->DeleteContents();
	pDoc->m_robots.RemoveAt(pDoc->m_selectedRobot);
	pDoc->m_selectedRobot = -1;

//	sLock.Unlock();

	Invalidate();
}