paintlazys.cpp

这是书上的代码

	bbb.y=int(Bang1.y);
	if (!rect.PtInRect(bbb))
		return FALSE;
	else
	{
		//进一步判断点是否在曲线上		
		double yyyy=calculate(Bang1.x,mm,nn);
		if(fabs(yyyy-Bang1.y)<5)
			return TRUE;
		else
			return FALSE;
	}
}

void CPaintLazys::GetBoundingRect(double &minx,double &miny,double &maxx,double &maxy)
{
	double xmin,xmax,ymin,ymax;
	xmin=min(m_pointPrimary.x,m_pointEnd.x);
	xmax=max(m_pointPrimary.x,m_pointEnd.x);
	ymin=min(m_pointPrimary.y,m_pointEnd.y);
	ymax=max(m_pointPrimary.y,m_pointEnd.y);
	minx=xmin;
	miny = ymin;
	maxx =xmax;
	maxy =ymax;
}

void CPaintLazys::Serialize(CArchive& ar)
{
	CPainted::Serialize(ar);
	if (ar.IsStoring())
	{
		ar << m_pointEnd;
		ar << m_angStart;
	
	}
	else
	{
		ar >> m_pointEnd;
		ar >> m_angStart;
	}
}


void CPaintLazys::onup1(CPnt& point1, CPnt& point2, CPnt& point3,CWnd *pWnd)
{	m_pointPrimary=point1;
	m_pointEnd=point2;
}

CPnt CPaintLazys::returnattr1()
{
	return m_pointPrimary;	
}
CPnt CPaintLazys::returnattr2()
{
	return	m_pointEnd;
}

//得到路径的绘制起点
//pnt1 为传递的鼠标点坐标或给定的起点坐标,
//id为返回点的ID,
//pnt为返回点的坐标,angle为返回点的姿态角
//return FALSE表示无就近点
//return TRUE表示有就近点
BOOL CPaintLazys::GetPathStartnode1(CPnt& pnt1,UINT& id,CPnt& pnt,double& angle)
{
	BOOL forreturn=FALSE;	
	CPainted*	pPainted;
	//若有一条参考线段并定义了参考点为其起点或终点
	if(m_pDoc->m_nGraphSelect==1 && m_pDoc->GraphSelect[0].Type>=0 && m_pDoc->GraphSelect[0].Type<=4)
	{
		pPainted =m_pDoc->GetShape(m_pDoc->GraphSelect[0].Index);
		if(!pPainted->m_bReferencePoint)//参考点为终点
		{	
			CPnt ppp;
			ppp=pPainted->returnattr2();
			pnt=ppp;			
			angle=pPainted->m_EndPostureAngle;
			id=pPainted->m_uEndNodeId;	
			forreturn=TRUE;							
		}
		else//参考点为起点
		{			
			CPnt ppp;
			ppp=pPainted->returnattr1();
			pnt=ppp;
			angle=pPainted->m_StartPostureAngle;
			id=pPainted->m_uStartNodeId;	
			forreturn=TRUE;
		}
	}
	else//若没有一条参考线段
	{
		int nShapes = m_pDoc->NumShapes();
		for (int index = 0; index < nShapes; index++)
		{
			pPainted =(CPainted*) m_pDoc->GetShape(index);
			forreturn=pPainted->NearJudge2(pnt1,id,pnt,angle);
			if(forreturn)
				break;
		}
	}
	return forreturn;
}
//得到路径的绘制起点
//画线时自动取就近的线条端点为起点
//起点为直线端点时return 1;
//起点为圆弧端点时return 2;
//起点为鼠标点时return 0;（即鼠标点距离就近的线条端点超过规定的范围）
//pnt1 为传递的鼠标点坐标，成功则赋值为就近的线条端点坐标，不成功则无意义
//pnt2 成功则为直线的另一端点或圆弧的圆心，不成功则无意义
int CPaintLazys::GetPathStartnode(CPnt& pnt1, CPnt& pnt2)
{
	
	return 1;
}

//得到路径的绘制终点
//返回值==FALSE时表示终点独立（不与任何节点相连）
//返回值==TRUE时表示终点与某节点相连
//
BOOL CPaintLazys::GetPathEndnode1(CPnt& pnt1)
{
	BOOL  forreturn=FALSE;
	CPainted*	pPainted;		
	if(m_pDoc->m_LazysPaintMode==2)
	{
		pnt1=m_pDoc->m_pPaintEndNode;//绘图时给定的终点		
	}		
	int nShapes = m_pDoc->NumShapes();
	for (int index = 0; index < nShapes; index++)
	{
		UINT id;
		CPnt pnt;
		double angle;
		pPainted =(CPainted*) m_pDoc->GetShape(index);
		forreturn=pPainted->NearJudge2(pnt1,id,pnt,angle);
		if(forreturn)
		{
			pnt1=pnt;
			m_pDoc->m_uCurEndnodeId=id;
			break;
		}				
	}
	return forreturn;
}


//得到路径的绘制终点
//返回值==FALSE时表示终点独立（不与任何节点相连）
//返回值==TRUE时表示终点与某节点相连
//
BOOL CPaintLazys::GetPathEndnode(CPnt& pnt1)
{	
	 return 1;
}

/*
double CPaintLazys::Distance1(double x1, double y1, double x2, double y2)
{
return (double)sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}

void CPaintLazys::toChar(char *p_Char)
{
	double x1,y1,x2,y2,Speed,Length,Angle;
	UINT PathId,StartId,StartType,EndId,EndType,HeadDir,Guide,Obstacle;
	x1=m_pointPrimary.x;
	y1=m_pointPrimary.y;
	x2=m_pointEnd.x;
	y2=m_pointEnd.y;

	Speed=m_fPathLimit;//速度限制
	Length=m_flength;//直线长度
	Angle=m_fangle;//直线角度
	PathId=m_uPathId;//路径ID 5
	StartId=m_uStartNodeId;//起点ID 5
	StartType=m_uStartNodeType;//起点类型 2
	EndId=m_uEndNodeId;//终点ID 5
	EndType=m_uEndNodeType;//终点类型 2
	HeadDir=m_uPathHeading;//路径车头方向 2
	Guide=m_uPathGuideType;//导航方式 1
	Obstacle=m_uPathObstacle;//路径障碍物模式 4	
	char p1[126];
	//把格式化数据写到字符串
	sprintf(p1,"%12.4f,%12.4f,%12.4f,%12.4f,%12.4f,%12.4f,%12.4f,%5d,%5d,%2d,%5d,%2d,%2d,%1d,%4d\n",
		x1,y1,x2,y2,Speed,Length,Angle,PathId,StartId,
		StartType,EndId,EndType,HeadDir,Guide,Obstacle);
	p1[125]=0;
	lstrcat(p_Char,p1);//增加在p_Char字符串后
}

char * CPaintLazys::toData(char *p_Char)
{
	float x1,y1,x2,y2,Speed,Length,Angle;
	UINT PathId,StartId,StartType,EndId,EndType,HeadDir,Guide,Obstacle;
	char p1[126];
	strncpy(p1,p_Char,125);	//拷贝一个125字节长度的字符串
	p_Char+=125;			//指向成员变量的字符串后的位置
	p1[125]=0;
	//从字符串读格式化数据
	sscanf(p1,"%f,%f,%f,%f,%f,%f,%f,%d,%d,%d,%d,%d,%d,%d,%d\n",
		&x1,&y1,&x2,&y2,&Speed,&Length,&Angle,&PathId,&StartId,
		&StartType,&EndId,&EndType,&HeadDir,&Guide,&Obstacle);
	m_pointPrimary.x=x1;
	m_pointPrimary.y=y1;
	m_pointEnd.x=x2;
	m_pointEnd.y=y2;

	m_fPathLimit=Speed;//速度限制
	m_flength=Length;//直线长度
	m_fangle=Angle;//直线角度
	m_uPathId=PathId;//路径ID
	m_uStartNodeId=StartId;//起点ID
	m_uStartNodeType=StartType;//起点类型
	m_uEndNodeId=EndId;//终点ID
	m_uEndNodeType=EndType;//终点类型
	m_uPathHeading=HeadDir;//路径车头方向
	m_uPathGuideType=Guide;//导航方式
	m_uPathObstacle=Obstacle;//路径障碍物模式
	return p_Char;			//返回指向成员变量的字符串后的位置
}
*/

void CPaintLazys::Move(double x_Move,double y_Move)
{
	//移动直线的起点和终点坐标
	m_pointPrimary.x+=x_Move;
	m_pointEnd.x+=x_Move;
	m_pointPrimary.y+=y_Move;
	m_pointEnd.y+=y_Move;
}




void CPaintLazys::toChar(char *p_Char)
{
	
}

char * CPaintLazys::toData(char *p_Char)
{
	
	return p_Char;			//返回指向成员变量的字符串后的位置
}

void CPaintLazys::ChangeOrigin(CPnt pnt)//改变坐标原点
{	
	m_pointPrimary.x=m_pointPrimary.x-pnt.x;
	m_pointPrimary.y=m_pointPrimary.y-pnt.y;
	m_pointEnd.x=m_pointEnd.x-pnt.x;
	m_pointEnd.y=m_pointEnd.y-pnt.y;
}

//返回路段给定端点的姿态角(外射角)
double CPaintLazys::ReturnPostureAngle(UINT id)
{
	double angle;
	if(m_uStartNodeId==id)
		angle=m_StartPostureAngle;
	else
		angle=m_EndPostureAngle;
	return angle;
}

void CPaintLazys::GetPostureAngle()//计算得到路段的姿态角(外射角)
{
	m_StartPostureAngle=m_angStart+pi;
	if(m_StartPostureAngle>=2*pi) m_StartPostureAngle-=2*pi;
	m_EndPostureAngle=m_angStart;

}

//就近点判断函数,	
//pnt1为鼠标点坐标或计算得到的准终点坐标,
//id为返回点的ID,pnt为返回点的坐标,angle为返回点的姿态角
//此函数只用于得到路径的终点!!
//返回值为TRUE表示有就近点,FALSE表示无就近点
//当GetPathEndnode()函数调用此函数时
//应根据是否满足相切条件来决定此函数返回数据的取舍
BOOL CPaintLazys::NearJudge2(CPnt pnt1,UINT& id,CPnt& pnt,double& angle)
{
	BOOL forreturn=FALSE;
	CPoint pointPrimary1,pointEnd1,point1;		
	DPtoVP(m_pointPrimary,pointPrimary1);
	DPtoVP(m_pointEnd,pointEnd1);
	DPtoVP(pnt1,point1);		
	if(Distance(point1.x,point1.y,pointPrimary1.x,pointPrimary1.y)<5)
	{				
		pnt.x=m_pointPrimary.x;
		pnt.y=m_pointPrimary.y;
		angle=m_StartPostureAngle;
		id=m_uStartNodeId;
		forreturn=TRUE;
	}
	else if(Distance(point1.x,point1.y,pointEnd1.x,pointEnd1.y)<5)
	{
		pnt.x=m_pointEnd.x;
		pnt.y=m_pointEnd.y;
		angle=m_EndPostureAngle;
		id=m_uEndNodeId;
		forreturn=TRUE;
	}	
	return forreturn;
}
//就近点判断函数,pnt1为鼠标点坐标,id为返回点的ID,pnt为返回点的坐标,angle为返回点的姿态角
//此函数只用于得到路径的起点!!
//返回值为TRUE表示有就近点,FALSE表示无就近点
BOOL CPaintLazys::NearJudge1(CPnt pnt1,UINT& id,CPnt& pnt,double& angle)
{
	BOOL forreturn=FALSE;
	if(m_pDoc->m_nGraphSelect==1&&m_bSelect==TRUE)//若为参考线段
	{		
		if(!m_bReferencePoint)//参考点为终点
		{
			pnt.x=m_pointEnd.x;
			pnt.y=m_pointEnd.y;
			angle=m_EndPostureAngle;
			id=m_uEndNodeId;	
			forreturn=TRUE;
		}
		else//参考点为起点
		{
			pnt.x=m_pointPrimary.x;
			pnt.y=m_pointPrimary.y;
			angle=m_StartPostureAngle;
			id=m_uStartNodeId;
			forreturn=TRUE;
		}
	}
	else//若不为参考线段
	{		
		CPoint pointPrimary1,pointEnd1,point1;		
		DPtoVP(m_pointPrimary,pointPrimary1);
		DPtoVP(m_pointEnd,pointEnd1);
		DPtoVP(pnt1,point1);
		if(Distance(point1.x,point1.y,pointPrimary1.x,pointPrimary1.y)<5)
		{				
			pnt.x=m_pointPrimary.x;
			pnt.y=m_pointPrimary.y;
			angle=m_StartPostureAngle;
			id=m_uStartNodeId;
			forreturn=TRUE;
		}
		else if(Distance(point1.x,point1.y,pointEnd1.x,pointEnd1.y)<5)
		{
			pnt.x=m_pointEnd.x;
			pnt.y=m_pointEnd.y;
			angle=m_EndPostureAngle;
			id=m_uEndNodeId;
			forreturn=TRUE;
		}
	}
	return forreturn;
}



void CPaintLazys::IsDblClkPath(void *pTemp1, void *pTemp2)
{
	loop11:
	m_pDoc = (CPaintobjDoc*) pTemp1;
	CLazysAttrDlg lazysattr;				
	lazysattr.m_pDoc =(CPaintobjDoc*) pTemp1;
	lazysattr.m_pActive1=this;	
	lazysattr.m_dAngle=m_angStart*180.0/pi;	
	lazysattr.m_uEndId =m_uEndNodeId;

	lazysattr.m_uId = m_uPathId;
	UINT id=m_uPathId;
	lazysattr.m_dLimit = m_fPathLimit;
	lazysattr.m_uStartId =m_uStartNodeId;
	lazysattr.m_nGuide=m_uPathGuideType;
	int result=lazysattr.DoModal();
	if(result==IDOK)
	{
		//如果更改了路径编号,不能与某存在的路径编号相同
		//必须定义新的路径编号
		CPainted*	pPainter;				
		if(id!=lazysattr.m_uId)
		{
			BOOL breturn=FALSE;
			int nShapes = m_pDoc->NumShapes();
			for (int index = 0; index < nShapes; index++)
			{
				pPainter =m_pDoc->GetShape(index);
				if(pPainter->m_uPathId==lazysattr.m_uId)
				{
					CString str="更改后的路径编号不能与某存在的路径编号相同，必须重新定义新的路径编号!";
					AfxMessageBox(str);
					breturn=TRUE;
					break;
				}
			}
			if(breturn)	{goto loop11;}
		}
		
//		m_uPathHeading=lazysattr.m_nHead;
		m_uPathId=lazysattr.m_uId;
		m_fPathLimit=lazysattr.m_dLimit;
		m_uPathGuideType=lazysattr.m_nGuide;
		m_pDoc->GetPathIdMax();			
	}
}

void CPaintLazys::IsDblClkBuilding(void *pTemp1, void *pTemp2)
{
	CBuildingLazysAttrDlg lazysattr;	
	lazysattr.m_dAngle=m_angStart*180.0/pi;	
	lazysattr.m_dStartx=m_pointPrimary.x;//起点坐标
	lazysattr.m_dStarty=m_pointPrimary.y;//起点坐标
	lazysattr.m_dEndx=m_pointEnd.x;//终点坐标
	lazysattr.m_dEndy=m_pointEnd.y;//终点坐标
	int result=lazysattr.DoModal();
	if(result==IDOK)
	{		
		if(m_pointPrimary.x!=lazysattr.m_dStartx||m_pointPrimary.y!=lazysattr.m_dStarty
			||m_pointEnd.x!=lazysattr.m_dEndx||m_pointEnd.y!=lazysattr.m_dEndy)
		{
			m_pointPrimary.x=lazysattr.m_dStartx;//起点坐标
			m_pointPrimary.y=lazysattr.m_dStarty;//起点坐标
			m_pointEnd.x=lazysattr.m_dEndx;//终点坐标
			m_pointEnd.y=lazysattr.m_dEndy;//终点坐标		
			GetPostureAngle();
			((CPaintobjView*) pTemp2)->Invalidate();
		}
	}
}

void CPaintLazys::IsDblClkDevice(void *pTemp1, void *pTemp2)
{
	CDeviceLazysAttrDlg lazysattr;	
	lazysattr.m_nDeviceId=m_nDeviceId;
	lazysattr.m_nSomeStatus=m_nSomeStatus;
	lazysattr.m_nStatusNumber=m_nStatusNumber;
	lazysattr.m_dAngle=m_angStart*180.0/pi;	
	lazysattr.m_dStartx=m_pointPrimary.x;//起点坐标
	lazysattr.m_dStarty=m_pointPrimary.y;//起点坐标
	lazysattr.m_dEndx=m_pointEnd.x;//终点坐标
	lazysattr.m_dEndy=m_pointEnd.y;//终点坐标
	int result=lazysattr.DoModal();
	if(result==IDOK)
	{
		m_nDeviceId=lazysattr.m_nDeviceId;
		m_nSomeStatus=lazysattr.m_nSomeStatus;
		m_nStatusNumber=lazysattr.m_nStatusNumber;
		if(m_pointPrimary.x!=lazysattr.m_dStartx||m_pointPrimary.y!=lazysattr.m_dStarty
			||m_pointEnd.x!=lazysattr.m_dEndx||m_pointEnd.y!=lazysattr.m_dEndy)
		{
			m_pointPrimary.x=lazysattr.m_dStartx;//起点坐标
			m_pointPrimary.y=lazysattr.m_dStarty;//起点坐标
			m_pointEnd.x=lazysattr.m_dEndx;//终点坐标
			m_pointEnd.y=lazysattr.m_dEndy;//终点坐标		
			GetPostureAngle();
			((CPaintobjView*) pTemp2)->Invalidate();
		}
	}
}



//用CPath数据初始化CPaintLine数据
void CPaintLazys::Init(CPath* pPath)
{
	CLazysPath* pLazysPath=((CLazysPath*) pPath);
	USHORT StartNodeId=pLazysPath->m_uStartNode;//起点ID
	USHORT EndNodeId=pLazysPath->m_uEndNode;//终点ID
	CNode* pStartNode=m_pDoc->GetNode(StartNodeId);
	CNode* pEndNode=m_pDoc->GetNode(EndNodeId);

	
	m_pointPrimary=CPnt(pStartNode->x,pStartNode->y);//起点坐标	
	m_uStartNodeId=StartNodeId;//起点ID
	m_uStartNodeType=pStartNode->m_uType;//起点类型
	m_uStartNodeExtType=pStartNode->m_uExtType;//起点扩展类型
	m_fStartHeading=pStartNode->m_fHeading;//起点车头方向角（度）

	m_pointEnd=CPnt(pEndNode->x,pEndNode->y);//终点坐标
	m_uEndNodeId=EndNodeId;//终点ID
	m_uEndNodeType=pEndNode->m_uType;//终点类型
	m_uEndNodeExtType=pEndNode->m_uExtType;//终点扩展类型
	m_fEndHeading=pEndNode->m_fHeading;//终点车头方向角（度）

	m_uFigureType=2;		//路径类型
	m_uPathId=pLazysPath->m_uId;		//路径ID
	m_fPathLimit=pLazysPath->m_fVeloLimit;	//速度限制
	m_uPathGuideType=pLazysPath->m_uGuideType;	//导航方式
	m_uPathExtType=pLazysPath->m_uExtType;	//路径扩展类型		
	m_angStart=pLazysPath->m_angStart;   // 起点的倾斜角(世界坐标系中)
	m_uObjectType=0;//地图对象的类型0=路径1=建筑2=设备		
	
	GetPostureAngle();//计算得到路段的姿态角(外射角)	
	
}