WireRouting/include/Clip.h

#include "stdafx.h"
#include "KDtree.h"
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;

// 卡箍信息
struct Clip
{
	string name;			 // 名字
	P coord, dir;			 // 坐标和方向,dir的方向视为正面
	int emc;				 // 卡箍类型,未确定为0
	double dia;				 // 通过卡箍的线束捆直径
	double maxDia;			 // 卡箍允许通过的最大线束捆直径
	int id;					 // 卡箍标号
	int bundleNodeID;		 // 卡箍暂时属于哪个Bundle
	vector<double> diaset;	 // 已经通过卡箍的线缆半径集合
	vector<int> channelEdge; // 在近似通道中连接到的卡箍标号
	bool used;				 // 卡箍是否被使用

	Clip()
	{
		emc = 0;
		bundleNodeID = 0;
		maxDia = MAXDia;
		id = 0;
		used = 0;
	}

	// 清除所有通过卡箍的线和通道信息
	void clear()
	{
		diaset.clear();
		bundleNodeID = 0;
		used = 0;
	}

	// 在卡箍里加入直径为d的线缆
	inline void addwire(double d)
	{
		diaset.push_back(d);
		dia = sqrt(dia * dia + d * d);
	}

	// 返回通过卡箍的线束捆直径
	inline double getDia()
	{
		double dia1 = 1.154 * dia;
		if (dia1 >= 10)
			dia1 *= 1.235 / 1.154;
		return dia1;
	}

	// 判断直径为d的线缆能否通过
	inline bool transitable(double d)
	{
		double dia1 = sqrt(d * d + dia * dia);
		dia1 = 1.154 * dia;
		if (dia1 >= 10)
			dia1 *= 1.235 / 1.154;

		if (dia1 <= maxDia)
			return true;
		return false;
	}

	// 判断从p点到卡箍，应该从哪一面进入，正面为0，反面为1
	inline int inDir(P p)
	{
		double angle = Angle(coord - p, dir);
		if (angle > pi / 2)
			return 1;
		return 0;
	}
};

// 卡箍集，保存所有的卡箍信息
struct ClipSet
{
	Clip c[N];			// 卡箍集合，下标从1~clipnum
	int clipnum;		// 卡箍总和,卡箍标号范围1`clipnum
	map<P, int> clipid; // 根据点坐标找到卡箍标号

	ClipSet()
	{
		clipnum = 0;
	}

	// 清除通过卡箍的线缆信息
	void clearWire()
	{
		for (int i = 1; i <= clipnum; i++)
			c[i].clear();
	}

	// 新加入一个卡箍
	inline void addclip(P p, P d, string name, int emc)
	{
		clipnum++;
		c[clipnum].coord = p;
		c[clipnum].coord.ref = clipnum;
		c[clipnum].coord.type = 0;
		c[clipnum].coord.setDir(p - d);

		c[clipnum].id = clipnum;
		c[clipnum].dir = p - d;
		c[clipnum].name = name;
		c[clipnum].emc = emc;
		clipid[p] = clipnum;
	}

	// 添加通过卡箍的导线
	inline void addwire(int id, double d)
	{
		c[id].addwire(d);
	}
	inline void addwire(P &p, double d)
	{
		int id = clipid[p];
		c[id].addwire(d);
	}

	// 获取指向编号为id的卡箍的指针
	Clip *getClipPointer(int id, int bundleNodeID)
	{
		if (bundleNodeID != -1)
			c[id].bundleNodeID = bundleNodeID;
		return &c[id];
	}

	// 判断两个卡箍是否互相为最近(已知i最近的卡箍是j)
	inline bool bothConnect(int i, int j)
	{
		if (c[j].channelEdge.empty())
			return false;
		if (c[j].channelEdge[0] == i)
			return true;
		if (c[j].channelEdge.size() == 2 &&
			c[j].channelEdge[1] == i)
			return true;
		return false;
	}

	// 判断卡箍能否通过
	inline bool transitable(int id, int emc, double d)
	{
		if (c[id].emc != emc)
			return false;
		return c[id].transitable(d);
	}

	// 根据卡箍位置估计飞机的近似中心线
	inline void computeCenter()
	{
		Ycenter = 0;
		Zcenter = 0;
		for (int i = 1; i <= clipnum; i++)
		{
			Clip clip = c[i];
			P tp = c[i].coord;
			Ycenter += tp.y;
			Zcenter += tp.z;
			MAXX = max(MAXX, tp.x);
			MINX = min(MINX, tp.x);

			MAXY = max(MAXY, tp.y);
			MINY = min(MINY, tp.y);

			MAXZ = max(MAXZ, tp.z);
			MINZ = min(MINZ, tp.z);
		}
		Ycenter /= clipnum;
		Zcenter /= clipnum;
	}

	// 打印卡箍距离近似中心线的距离
	inline void printDis()
	{
		for (int i = 1; i <= clipnum; i++)
		{
			Clip clip = c[i];
			P tp = c[i].coord;
			double dis = (Ycenter - tp.y) * (Ycenter - tp.y) + (Zcenter - tp.z) * (Zcenter - tp.z);
			cout << sqrt(dis) << endl;
		}
	}

	// 根据卡箍位置先创建一个近似的通道，每个卡箍连到距离最近的两个卡箍
	inline void buildChannel()
	{
		vector<int> pointSet;
		bool flag = false; // flag=true时代表这个卡箍需要重新计算
		double sumDis = 300;
		int sum = 1;
		for (int i = 1; i <= clipnum; i++)
		{
			if (pointSet.empty() || flag)
			{
				pointSet = kdtree.search_by_dis(c[i].coord, segmentLength);
				c[i].channelEdge.clear();
			}
			vector<pair<double, int>> vp;
			for (int j = 0; j < pointSet.size(); j++)
			{
				int cid = pointSet[j];
				if (cid == i)
					continue;
				if (c[i].coord == c[cid].coord)
					continue;
				double dis = distan(c[i].coord, c[cid].coord);
				vp.push_back(make_pair(dis, cid));
			}
			sort(vp.begin(), vp.end());
			P dir;
			for (int j = 0; j < vp.size(); j++)
			{
				int cid = vp[j].second;
				if (vp[j].first > 2 * sumDis / sum)
					break;
				if (j == 0)
				{
					c[i].channelEdge.push_back(cid);
					dir = c[cid].coord - c[i].coord;
					sum++;
					sumDis += vp[j].first;
				}
				else
				{
					P dir2 = c[cid].coord - c[i].coord;
					if (Angle(dir, dir2) >= pi / 2 - minAngle)
					{
						c[i].channelEdge.push_back(cid);
						sum++;
						sumDis += vp[j].first;
						break;
					}
				}
			}
			if (c[i].channelEdge.size() < 2 && !flag)
				flag = true, i--;
			else
				flag = false;
		}
	}

	// 打印所有卡箍信息到clipDir文件，卡箍坐标后面会加上卡箍类型
	/*
		0代表航向卡箍
		1代表垂直向卡箍
		2代表其他方向卡箍
	*/
	inline void print()
	{
		ofstream ofs;
		ofs.open("clipDir.txt", ios::out);
		for (int i = 1; i <= clipnum; i++)
		{
			Clip clip = c[i];
			P tp = c[i].coord;
			P dirtp = c[i].dir;
			ofs << tp.x << "  " << tp.y << "  " << tp.z;
			double angel = Angle(dirtp, DX);
			// if(angel>pi/2)angel=pi-angel;
			// angel=min(angel,pi/2-angel);
			if (angel <= minAngle || angel >= pi - minAngle)
				ofs << 0 << endl;
			else if (angel >= pi / 2 - minAngle && angel <= pi / 2 + minAngle)
				ofs << 1 << endl;
			else
				ofs << 2 << endl;
		}
	}

} clipSet;