WireRouting/WireRouting_DLL/Bundle.cpp

#include "pch.h" // use stdafx.h in Visual Studio 2017 and earlier
#include "Bundle.h"

BundleNode bdNode[MAXPointNum];
int bdNodeNum = 0; //用数组维护BundleNode信息


BundleNode::BundleNode(){
	pre=next=NULL;
	pc=NULL;pb=NULL;pcn=NULL;
	type=0;inOut=0;
	bundleID=0;
	id=0;
}

P BundleNode::coord(){
	if(type==0)return pc->coord;
	return pb->coord;
}

void Bundle::init(){
	length=0;
	abandoned=false;
	head=tail=NULL;
}

Bundle::Bundle(){
	init();
}

//创建一个分支点,初始化其除了链表指针外的其他信息
BundleNode* Bundle::createBundleNode(P& tp,int inOut,int bundleID){
	bdNodeNum++;
	BundleNode * pbn=&bdNode[bdNodeNum];
	pbn->id=bdNodeNum;
	pbn->bundleID=bundleID;
	pbn->inOut=inOut;
	pbn->rev=0;
	pbn->pre=NULL;
	pbn->next=NULL;
	if(tp.type==0){	//点是卡箍
		pbn->type=0;
		pbn->pc=clipSet.getClipPointer(tp.ref,bdNodeNum);
	}
	else if(tp.type==1||tp.type==2){	//点是分支点
		pbn->type=1;
		pbn->pb=branchPointSet.getBranchPointPointer(tp.ref);
	}
	else if(tp.type==3){
		pbn->type=2;
		pbn->pcn=&connectors[tp.ref];
		connectors[tp.ref].bundleNodeID=bdNodeNum;
	}
	return pbn;
}

//根据简单路径构建一个Bundle
 Bundle::Bundle(Path& path,int bundleID){
	 init();
	 this->id=bundleID;
	 this->length=path.size();
	 BundleNode * pre = nullptr;
	 for(int i=0;i<path.size();i++){
		 P tp=path.points[i];
		 BundleNode* pbn=Bundle::createBundleNode(tp,path.inOut[i],bundleID);
		 if(i==path.size()-1)this->tail=pbn;
		 if(i==0)this->head=pbn;
		 else {
			 pre->next=pbn;
			 pbn->pre=pre;
			}
		 pre=pbn;			
	 }
}

//如果首个节点是分支点，返回分支点的标号，否则返回0
int  Bundle::startBranchPoint(){
	if(head==NULL)return 0;
	if(head->type==0||head->type==2)return 0;
	return head->pb->id;		
}

//如果尾部节点是分支点，返回分支点的标号，否则返回0
int  Bundle::endBranchPoint(){
	if(tail==NULL)return 0;
	if(tail->type==0||tail->type==2)return 0;
	return tail->pb->id;
}

//更新输出信息
void Bundle::updateOutput(vector<vector<pair<int,int> > >& resClip,
	vector<vector<int> >& resBranchPoint,
	vector<int>& startBranchPoint,
	vector<int>& endBranchPoint,
	bool basic){
	if(head==NULL)return;
	BundleNode *pbn=head;
	vector<pair<int,int> > partClip;
	vector<int> partBranchPoint;
	int partStart=this->startBranchPoint();
	int partEnd=this->endBranchPoint();
	while(pbn!=NULL){
		if(pbn->type==0){	//卡箍
			int cid=pbn->pc->id;
			if((pbn->pc->used==true)||basic){
				partClip.push_back(make_pair(cid,pbn->inOut));
				for(int i=0;i<pbn->vb.size();i++){
					int bid=pbn->vb[i];
					BranchPoint *pb=branchPointSet.getBranchPointPointer(bid);
					if((pb->used==true)||basic)
						partBranchPoint.push_back(bid);
				}
			}
			else {
				if(partClip.size()!=0){
					resClip.push_back(partClip);
					resBranchPoint.push_back(partBranchPoint);
					startBranchPoint.push_back(partStart);
					endBranchPoint.push_back(partEnd);
				}
				partClip.clear();
				partBranchPoint.clear();
			}
		}
		else if(pbn->type==2){	//连接器
			int cnid=pbn->pcn->ID;
			partClip.push_back(make_pair(cnid,-1));
		}
		pbn=pbn->next;
	}
	if(!basic){
		if(partClip.size()!=0){
			resClip.push_back(partClip);
			resBranchPoint.push_back(partBranchPoint);
			startBranchPoint.push_back(partStart);
			endBranchPoint.push_back(partEnd);
		}
	}
	else{
		if(partClip.size()>5){
			resClip.push_back(partClip);
			resBranchPoint.push_back(partBranchPoint);
			startBranchPoint.push_back(partStart);
			endBranchPoint.push_back(partEnd);
		}
	}
}