analyzer.cpp

The application wizard has created this SoccerDoctor application for you. This application not onl

	vBasicEvent.clear();
	BasicBehaviorEvent tempEvent;
	tempEvent.time=0;
	tempEvent.team=-1;
	tempEvent.player=-1;
	tempEvent.type=BB_NONE;
	vBasicEvent.push_back(tempEvent);
	_sInnerState.ballKickableForPlayer=false;
	_sInnerState.lastCycleBallKickableForPlayer=false;
	_sInnerState.lastCyclePlayerWithBall=-1;
	_sInnerState.lastCyclePlayMode=PM_BeforeKickOff;
	_sInnerState.lastCycleScoreLeft=0;
	_sInnerState.lastCycleScoreRight=0;
	_sInnerState.lastCycleTeamWithBall=-1;
	_sInnerState.parameterNeedFillBack=false;
	_sInnerState.playerWithBall=-1;
	_sInnerState.playerWithBallChange=false;
	_sInnerState.playMode=PM_BeforeKickOff;
	_sInnerState.prePlayerWithBall=-1;
	_sInnerState.preTeamWithBall=0;
	_sInnerState.scoreLeft=0;
	_sInnerState.scoreRight=0;
	_sInnerState.teamWithBall=0;
	_sInnerState.teamWithBallChange=false;
	_sInnerState.statDataInvoked=false;
	_sInnerState.logLoaded=false;
	vPlayerPosition.clear();
	return 0;
}

//获得事件表指针的接口
const vector<BasicBehaviorEvent>& CAnalyzer::getBasicEventPointer() const{
	return vBasicEvent;
}

//获得位置表指针的接口
const vector<PointFrameT>& CAnalyzer::getPlayerPositionPointer() const{
	return vPlayerPosition;
}

//获取某个周期某个球员的行为
struct BasicBehaviorEvent CAnalyzer::getPlayerBehavior(int cycle,int side,int unum) const{
	struct BasicBehaviorEvent rt;
	rt.time=cycle;
	rt.team=side;
	rt.player=unum;
	
	if(side==LEFT){
		unum-=1;
		side=0;
	}else{
		unum+=10;
		side=1;
	}
	int i=0;
	do 
		i++;
	while(vBasicEvent[i].time<cycle && i<(int)vBasicEvent.size()-1);
	if(i==(int)vBasicEvent.size()-1 && vBasicEvent[i].time<cycle){
		rt.type=BB_NONE;
	}else{
		if(vBasicEvent[i].time==cycle){
			if(vBasicEvent[i].player==unum){
				rt.type=vBasicEvent[i].type;
				rt.obj=vBasicEvent[i].obj;
				rt.pt=vBasicEvent[i].pt;
				rt.success=vBasicEvent[i].success;
			}else{
				rt.type=BB_POSITION;
			}
		}else{
			if(i>0)
				if(vBasicEvent[i-1].player==unum){
					rt.type=vBasicEvent[i-1].type;
					rt.obj=vBasicEvent[i-1].obj;
					rt.pt=vBasicEvent[i-1].pt;
					rt.success=vBasicEvent[i-1].success;
				}else{
					rt.type=BB_POSITION;
				}
			else
				rt.type=BB_NONE;
		}
	}
	return rt;
};

//PointT的初始化函数
PointT::PointT(){
}

PointT::PointT(double _x,double _y){
	x=_x;
	y=_y;
}

//点到区域的转化函数
int CAnalyzer::point2Region(PointT pt){
	int row=(int) ( (pt.y+FIELDWIDTH/2)/region_height );
	int vol=(int) ( (pt.x+FIELDLENGTH/2)/region_width );
	return row*1000+vol;
}



//*******************************************************************
//		计划识别
//*******************************************************************

//sEvent的查找函数

//计划识别的函数
int CAnalyzer::planRecognization(){
	
	//初始化基本事件队列和计划识别网络
	vEvent.clear();
	vMAPRN.clear();

	//生成基本事件队列
    createBasicEvent();
	
	//优化基本行为序列
	refineVEvent();

	//debug
	outputVEvent();

	//构建Trie
	createTrie();

	//对Trie剪枝
	pruningTrie(pTrieRoot,0);

	//输出Trie
	outputTrie(pTrieRoot);
	
	//生成计划识别网络
	createMAPRN();

	//debug
	outputMAPRN();

	//计划提取
	refinePlan();

	//释放Trie
	releaseTrie(pTrieRoot);

	return 0;
};

//生成基本事件队列
int CAnalyzer::createBasicEvent()
{
	MAPREVENT tempEvent;
	vector<MAPREVENT> eventVector;
	int leadingPlayer;
	int tempTime;
	set<int> assosiatTeammates;
	//提取出一次进攻中参与的球员号
	int team=vBasicEvent[1].team;
	assosiatTeammates.clear();
	int j=1;
	while(vBasicEvent[j].team==team){
		assosiatTeammates.insert(vBasicEvent[j].player);
		j++;
	}
	for(int i=1;i<(int)vBasicEvent.size();i++){
		//提取出一次进攻中参与的球员号
		if(vBasicEvent[i].team!=team){
			j=i;
			team=1-team;
			assosiatTeammates.clear();
			while(vBasicEvent[j].team==team){
				assosiatTeammates.insert(vBasicEvent[j].player);
				j++;
			}
		}
		
		//处理主导行为
		switch(vBasicEvent[i].type){
			case BB_SHOOT:
				tempEvent.player=tempEvent.goalPlayer=vBasicEvent[i].player;
				tempEvent.type=BB_SHOOT;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				eventVector.push_back(tempEvent);
				break;
			case BB_PASS:
				tempEvent.player=vBasicEvent[i].player;
				tempEvent.type=BB_PASS;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				tempEvent.goalPlayer=vBasicEvent[i].obj.unum;
				eventVector.push_back(tempEvent);
				break;
			case BB_DRIBBLE:
				tempEvent.player=tempEvent.goalPlayer=vBasicEvent[i].player;
				tempEvent.type=BB_DRIBBLE;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				eventVector.push_back(tempEvent);
				break;
			case BB_CLEARBALL:
				tempEvent.player=tempEvent.goalPlayer=vBasicEvent[i].player;
				tempEvent.type=BB_CLEARBALL;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				eventVector.push_back(tempEvent);
				break;
			case BB_ADJUST:
				tempEvent.player=tempEvent.goalPlayer=vBasicEvent[i].player;
				tempEvent.type=BB_ADJUST;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				eventVector.push_back(tempEvent);
				break;
			case BB_RECEIVE:
				tempEvent.player=tempEvent.goalPlayer=vBasicEvent[i].player;
				tempEvent.type=BB_RECEIVE;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				eventVector.push_back(tempEvent);
				break;
			case BB_INTERCEPT:
				tempEvent.player=tempEvent.goalPlayer=vBasicEvent[i].player;
				tempEvent.type=BB_INTERCEPT;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				eventVector.push_back(tempEvent);
				break;
			case BB_POSITION:
				tempEvent.player=tempEvent.goalPlayer=vBasicEvent[i].player;
				tempEvent.type=BB_POSITION;
				tempEvent.sourceRegion=point2Region(vBasicEvent[i].pt);
				tempEvent.goalRegion=point2Region(vBasicEvent[i].obj.pt);
				eventVector.push_back(tempEvent);
				break;
			default:
				break;
		}
		//记录主导行为的产生球员
		leadingPlayer=vBasicEvent[i].player;
		tempTime=vBasicEvent[i].time;
		int ixs=1,ixg;
		while(vPlayerPosition[ixs].time!=tempTime && ixs<(int)vPlayerPosition.size()-1) ixs++;
		ixg=ixs;
		if(i==((int)vBasicEvent.size()-1)){
			tempTime=vBasicEvent[i].time;
		}else{
			tempTime=vBasicEvent[i+1].time;
		}
		while(vPlayerPosition[ixg].time!=tempTime && ixg<(int)vPlayerPosition.size()-1) ixg++;

		//处理参与此次进攻的球员的辅助行为
		set<int>::iterator it;
		for(int p=0;p<MAX_PLAYER*2;p++){
			it=assosiatTeammates.find(p);
			if(it!=assosiatTeammates.end()){
				if((*it)!=leadingPlayer){
					//球员在该次进攻中，则记录其行为
					if(ixs==vPlayerPosition.size()-1 || ixg==vPlayerPosition.size()-1){
						//没有该时刻位置信息，报错
					}else{
						tempEvent.type=BB_POSITION;
						tempEvent.player=tempEvent.goalPlayer=p;
						tempEvent.sourceRegion=point2Region(vPlayerPosition[ixs].pFrame[p]);
						tempEvent.goalRegion=point2Region(vPlayerPosition[ixg].pFrame[p]);
						eventVector.push_back(tempEvent);
					}
				}
			}
		}

		//填写基本行为事件队列
		vEvent.push_back(eventVector);
		//清空临时变量
		eventVector.clear();
	}
	return 0;
}

//生成计划识别网络
int CAnalyzer::createMAPRN()
{
	vector<MAPREVENT> eventVectorFrame;
	MAPREVENT leadingEvent;
	int pLeadingEvent;
	MAPRNNode tempNode;
	for(int i=0;i<(int)vEvent.size();i++){
		//取出同时发生的几个事件
		eventVectorFrame=vEvent[i];
		//处理主导行为
		leadingEvent=eventVectorFrame[0];
		//看看是否已发生过这样的事件
		pLeadingEvent=findEventInMAPRN(leadingEvent);
		if(pLeadingEvent==vMAPRN.size()){
			//如果没有则插入该事件
			tempNode.event.type=leadingEvent.type;
			tempNode.event.player=leadingEvent.player;
			tempNode.event.sourceRegion=leadingEvent.sourceRegion;
			tempNode.event.goalRegion=leadingEvent.goalRegion;
			tempNode.event.goalPlayer=leadingEvent.goalRegion;
			tempNode.counts=1;
			tempNode.concurrent.clear();
			tempNode.follow.clear();
			vMAPRN.push_back(tempNode);
		}else{
			//否则修改该事件的记录
			vMAPRN[pLeadingEvent].counts++;
		}
		//处理并发辅助行为
		for(int j=1;j<(int)eventVectorFrame.size();j++){
			//处理一个并发事件
			int pConcurrentEvent=0;
			for(;pConcurrentEvent<(int)vMAPRN[pLeadingEvent].concurrent.size();pConcurrentEvent++){
				if(vMAPRN[vMAPRN[pLeadingEvent].concurrent[pConcurrentEvent].pEvent].event.type==eventVectorFrame[j].type
					&& vMAPRN[vMAPRN[pLeadingEvent].concurrent[pConcurrentEvent].pEvent].event.player==eventVectorFrame[j].player
					//&& vMAPRN[vMAPRN[pLeadingEvent].concurrent[pConcurrentEvent].pEvent].event.sourceRegion==eventVectorFrame[j].sourceRegion
					&& vMAPRN[vMAPRN[pLeadingEvent].concurrent[pConcurrentEvent].pEvent].event.goalRegion==eventVectorFrame[j].goalRegion){
					break;
				}else{
				}
			}
			if(pConcurrentEvent!=vMAPRN[pLeadingEvent].concurrent.size()){
				//如果已经在该事件的并发事件队列中，则计数
				vMAPRN[pLeadingEvent].concurrent[pConcurrentEvent].counts++;
			}else{
				//否则将其添加如该事件的并发事件队列中
				int pConcurrentEventNode=findEventInMAPRN(eventVectorFrame[j]);
				MAPRNPTR tempPTR;
				tempPTR.counts=1;
				if(pConcurrentEventNode==vMAPRN.size()){
					//如果没有则插入该事件
					tempNode.event.type=eventVectorFrame[j].type;
					tempNode.event.player=eventVectorFrame[j].player;
					tempNode.event.sourceRegion=eventVectorFrame[j].sourceRegion;
					tempNode.event.goalRegion=eventVectorFrame[j].goalRegion;
					tempNode.event.goalPlayer=eventVectorFrame[j].goalRegion;
					tempNode.counts=1;
					tempNode.concurrent.clear();
					tempNode.follow.clear();
					vMAPRN.push_back(tempNode);
				}else{
				}
				//令指针指向新加入的节点
				tempPTR.pEvent=pConcurrentEventNode;
				vMAPRN[pLeadingEvent].concurrent.push_back(tempPTR);
			}
		}
		//处理后续行为
		if(i!=(int)vEvent.size()-1){
			vector<MAPREVENT> nextEventVectorFrame=vEvent[i+1];
			for(int k=0 ;k<(int)nextEventVectorFrame.size();k++){
				//处理一个后继行为
				int pFollowEvent=0;
				while(pFollowEvent<(int)vMAPRN[pLeadingEvent].follow.size()){
					if( !(vMAPRN[vMAPRN[pLeadingEvent].follow[pFollowEvent].pEvent].event.type==nextEventVectorFrame[k].type
						&& vMAPRN[vMA