slsdef.cpp

快速原型制造分层切片源代码,适用于高温合金.

			int nextFaceIndex=m_edges[nextEdgeIndex].m_faces[0];
 			if (nextFaceIndex >= 0 )
			{
				while(true) 
				{
					ring.Add(m_pIntersections[nextEdgeIndex].m_intersection);
					m_pIntersections[nextEdgeIndex].m_status=DEALT;

					for (int j=0; j<3; j++)
					{
						nextEdgeIndex=m_faces[nextFaceIndex].m_edges[j];
						if (m_pIntersections[nextEdgeIndex].m_status==TOBEDEALT) 
						    break;
					}
	
					if (j>=3) 
						break; //The ring is broken or closed at this point

					nextFaceIndex= (m_edges[nextEdgeIndex].m_faces[0]
						            == nextFaceIndex) ?
								    m_edges[nextEdgeIndex].m_faces[1] :
								    m_edges[nextEdgeIndex].m_faces[0] ;
				}
			}

			// - order trip
			nextEdgeIndex=i;
			nextFaceIndex=m_edges[nextEdgeIndex].m_faces[1];
			if (nextFaceIndex >=0 )
			{
				while(true) 
				{
					for (int j=0; j<3; j++)
					{
						nextEdgeIndex=m_faces[nextFaceIndex].m_edges[j];
						if (m_pIntersections[nextEdgeIndex].m_status==TOBEDEALT) 
						    break;
					}

					if (j>=3) 
						break; //The ring is broken or closed at this point

					ring.InsertAt(0,m_pIntersections[nextEdgeIndex].m_intersection);
					m_pIntersections[nextEdgeIndex].m_status=DEALT;

					nextFaceIndex= (m_edges[nextEdgeIndex].m_faces[0]
					                == nextFaceIndex) ?
					        		m_edges[nextEdgeIndex].m_faces[1] :
									m_edges[nextEdgeIndex].m_faces[0] ;
				}
			}

			ProcessRing(ring); //处理短线段以及三点共线的情况

			if (ring.GetSize() > 2) 
			{
				ring.Find_Min_Max_Value();
				contour.Add(ring);
			}
		}

	}
	
	contour.Find_Min_Max_Value();
	contour.JudgeOuterLoops(); //判断内外环
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	for (i=0; i<m_points.GetSize(); i++)
	{
		if (dealtFlags[i]) 
			m_points[i].m_dZ=height;
	}

	delete dealtFlags;

	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	return 0;
}

////////////////////////////////////////////////////////////////
//implementation of CFIFO class

CFIFO::CFIFO()
{
	InitFIFO();
}

void CFIFO::InitFIFO(void)
{
	m_headPointer = m_tailPointer = 0;
}

bool CFIFO::IsFIFOFull(void)
{
	if(m_headPointer == ((m_tailPointer+1)%BUFFERSIZE))
		return TRUE;
	else
		return FALSE;
}

bool CFIFO::IsFIFOEmpty(void)
{
	if(m_headPointer == m_tailPointer)
		return TRUE;
	else
		return FALSE;
}

bool CFIFO::ReadFIFO(DWORD& data)
{
	if(IsFIFOEmpty())
	{
		return FALSE;
	}
	else
	{
		data = m_dwDataBuffer[m_headPointer];
		m_headPointer = (m_headPointer+1)%BUFFERSIZE;
		return TRUE;
	}
}

bool CFIFO::WriteFIFO(DWORD data)
{
	if(IsFIFOFull())
	{
		return FALSE;
	}
	else
	{
		m_dwDataBuffer[m_tailPointer] = data;
		m_tailPointer = (m_tailPointer+1)%BUFFERSIZE;
		return TRUE;
	}
}

long CFIFO::SizeOfDataInFIFO(void)
{
	long cnt;
	cnt = m_tailPointer - m_headPointer;

	if(cnt < 0)
		cnt += BUFFERSIZE;

	return cnt;
}

long CFIFO::SizeOfSpareSpace(void)
{
	long cnt;
	cnt = m_tailPointer - m_headPointer;

	if(cnt < 0)
		cnt += BUFFERSIZE;

	return ( (BUFFERSIZE - 1) - cnt );
}

////////////////////////////////////////////////////////////////
//implementation of CPathData class

int CIPInfo::GetFlagBit(int index)
{
	WORD flag = m_flag;
	flag &= (1 << index);
	return flag;
}

void CIPInfo::SetFlagBit(int index)
{
	m_flag |= (1 << index);
}

void CIPInfo::ResetFlagBit(int index)
{
	m_flag &= ~(1 << index);
}

DWORD CPathData::m_axisZPos = 0;
DWORD CPathData::m_axisVPos = 0;

bool CPathData::m_bLaserOn = false;

void CPathData::SetAxisInitPos(void)
{
	//清命令寄存器
	_outp(0x8321,0);
	
	//修改U轴和V轴的当前坐标
	_outpd(0x8324,m_axisZPos);
	_outpd(0x8325,m_axisVPos);
}

void CPathData::SetPathParam(pathParam& param)
{
	m_pathParam.m_ScanWidth=param.m_ScanWidth;           
	m_pathParam.m_LayerThickness=param.m_LayerThickness;       
	m_pathParam.m_RotateAngle=param.m_RotateAngle; 
	m_pathParam.m_ScanSpeed=param.m_ScanSpeed;
	m_pathParam.m_ZeroSpeed=param.m_ZeroSpeed;
	m_pathParam.m_LaserPower=param.m_LaserPower;
	m_pathParam.m_PowderUp=param.m_PowderUp;
	m_pathParam.m_PlatformDown=param.m_PlatformDown;
}

bool CPathData::Initialize(const char* inFileName)
{
	if(m_pFIFO != NULL)
	{
		delete m_pFIFO;
	}
	
	m_pFIFO	= new CFIFO;

	if(!m_Solid.Initialize(inFileName))
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

bool CPathData::CreatePathData(int curLayerNum)
{
	if(!m_Solid.m_bInitialized)
		return FALSE;
	
	double angle=m_pathParam.m_RotateAngle*curLayerNum;
	double currentHeight=m_Solid.m_zMin+m_pathParam.m_LayerThickness*curLayerNum;

	if(currentHeight > m_Solid.m_zMax)	//高度方向上的误差 < 单层厚度/2
	{
		if(fabs(currentHeight - m_Solid.m_zMax) < m_pathParam.m_LayerThickness/2.0)
		{
			currentHeight -= m_pathParam.m_LayerThickness/2.0;
		}
		else
		{
			return FALSE;
		}
	}
	else
	{
		if(currentHeight < m_Solid.m_zMin)
			return FALSE;
	}

	m_Solid.CutSlice(currentHeight, m_Contour);
	m_Contour.m_ScanWidth=m_pathParam.m_ScanWidth;
	m_Contour.ScanPathPerLayer(m_scanPath, angle);

	return TRUE;
}

void CPathData::WritePathDataIntoFIFO(double centerPosX, double centerPosY)
{
	int total_seg;
	int total_ring;
	long spareSpace;

	total_seg=m_scanPath.polylines.GetSize();
	total_ring=m_scanPath.polygons.GetSize();
	spareSpace=m_pFIFO->SizeOfSpareSpace();

	if(m_IPInfo.GetFlagBit(2))
		return;

	if(m_IPInfo.GetFlagBit(0))
	{
		if(spareSpace < 8)
			return;

		if(m_IPInfo.GetFlagBit(6))//叠层制造
		{
			m_axisZPos += m_pathParam.m_PlatformDown;
			m_axisVPos -= m_pathParam.m_PowderUp;

			//工作缸下降
			WriteOneDataIntoFIFO((m_axisZPos & 0xffffff) | 0x1000000);

			//粉桶上升
			WriteOneDataIntoFIFO((m_axisVPos & 0xffffff) | 0x2000000);

			//铺粉系列动作
			WriteOneDataIntoFIFO(0x55);

			//等待步进电机到位
			WriteOneDataIntoFIFO(-1);
			
			spareSpace -= 4;
		}

		//设定激光功率
		WriteOneDataIntoFIFO(m_pathParam.m_LaserPower);

		//设定轮廓扫描速度为5m/min
		WriteOneDataIntoFIFO(7);
		WriteOneDataIntoFIFO(2500000);

		//关闭激光
		WriteOneDataIntoFIFO(0x59);
		m_bLaserOn=false;

		spareSpace -= 4;
		m_IPInfo.ResetFlagBit(0);	//清除断点标志位
	}

	//处理所有轮廓
	int total_point;
	C2DPoint P, P0, P1;
	for(int i = m_IPInfo.m_1thIP; i < total_ring; i++)
	{
		//处理一个环
		total_point = m_scanPath.polygons[i].GetSize();
		for(int j = m_IPInfo.m_2thIP; j <= total_point; j++)
		{
			if(spareSpace < 6)
				return;
			
			if(j == 0)
			{
				P0 = m_scanPath.polygons[i][0];
//				P1 = m_scanPath.polygons[i][1];
				
//				//反向延长线
//				GetExtendedLine(P0, P1, P, false);
				if(m_bLaserOn)	//关闭激光
				{
					WriteOneDataIntoFIFO(0x59);
					m_bLaserOn=false;
					spareSpace --;
				}
/*				WriteOneDataIntoFIFO(3);
				WriteOneDataIntoFIFO(DWORD((P.m_dX+centerPosX)*500));
				WriteOneDataIntoFIFO(DWORD((P.m_dY+centerPosY)*500));
				spareSpace -= 3;
*/				
				//起始位置
				WriteOneDataIntoFIFO(3);
				WriteOneDataIntoFIFO(DWORD((P0.m_dX+centerPosX)*500));
				WriteOneDataIntoFIFO(DWORD((P0.m_dY+centerPosY)*500));
//				WriteOneDataIntoFIFO(8); //延迟100毫秒
//				WriteOneDataIntoFIFO(100);
				spareSpace -= 5;
			}
			else
			{
				if(j == total_point)
				{
//					P0 = m_scanPath.polygons[i][total_point-1];
					P1 = m_scanPath.polygons[i][0];
//					GetExtendedLine(P0, P1, P);

					//终止位置
					WriteOneDataIntoFIFO(3);
					WriteOneDataIntoFIFO(DWORD((P1.m_dX+centerPosX)*500));
					WriteOneDataIntoFIFO(DWORD((P1.m_dY+centerPosY)*500));
					
//					//正向延长线
					WriteOneDataIntoFIFO(0x59); //关闭激光
					m_bLaserOn=false;
//					WriteOneDataIntoFIFO(8); //延迟100毫秒
//					WriteOneDataIntoFIFO(100);
					spareSpace -= 6;
/*					WriteOneDataIntoFIFO(3);
					WriteOneDataIntoFIFO(DWORD((P.m_dX+centerPosX)*500));
					WriteOneDataIntoFIFO(DWORD((P.m_dY+centerPosY)*500));
					spareSpace -= 4;
*/				}
				else
				{
					P1 = m_scanPath.polygons[i][j];
					if(!m_bLaserOn)	//开启激光
					{
						WriteOneDataIntoFIFO(0x58);
						m_bLaserOn=true;
						spareSpace --;
					}
					WriteOneDataIntoFIFO(3);
					WriteOneDataIntoFIFO(DWORD((P1.m_dX+centerPosX)*500));
					WriteOneDataIntoFIFO(DWORD((P1.m_dY+centerPosY)*500));
					spareSpace -= 3;
				}
			}
			
			m_IPInfo.m_2thIP ++ ;	//修改断点指针 
		}	//end of one ring
		
		m_IPInfo.m_1thIP ++ ;	//修改断点指针
		m_IPInfo.m_2thIP = 0;	
	} //end of all rings					

	//设定内部填充线段扫描速度
	if(m_IPInfo.GetFlagBit(8))
	{
		if(spareSpace < 2)
			return;

		WriteOneDataIntoFIFO(7);
		WriteOneDataIntoFIFO(m_pathParam.m_ScanSpeed);
		spareSpace -= 2;
		m_IPInfo.ResetFlagBit(8);	//清除断点标志位
	}

	//处理填充线段
	C2DLine Li;
	for( i = m_IPInfo.m_3thIP; i < total_seg; i++)
	{
		if(spareSpace < 13)
			return;

		Li = m_scanPath.polylines[i];
		P0 = Li.m_startPoint;
		P1 = Li.m_endPoint;

//		//反向延长线
//		GetExtendedLine(P0, P1, P, false);
		WriteOneDataIntoFIFO(0x59);	//关闭激光
		m_bLaserOn=false;

/*		WriteOneDataIntoFIFO(3);
		WriteOneDataIntoFIFO(DWORD((P.m_dX+centerPosX)*500));
		WriteOneDataIntoFIFO(DWORD((P.m_dY+centerPosY)*500));
*/				
		//起始位置
		WriteOneDataIntoFIFO(3);
		WriteOneDataIntoFIFO(DWORD((P0.m_dX+centerPosX)*500));
		WriteOneDataIntoFIFO(DWORD((P0.m_dY+centerPosY)*500));

//		WriteOneDataIntoFIFO(8); //延迟100毫秒
//		WriteOneDataIntoFIFO(100);
		
		//终止位置
		WriteOneDataIntoFIFO(0x58); //开启激光
		m_bLaserOn=true;
		
		WriteOneDataIntoFIFO(3);
		WriteOneDataIntoFIFO(DWORD((P1.m_dX+centerPosX)*500));
		WriteOneDataIntoFIFO(DWORD((P1.m_dY+centerPosY)*500));

		WriteOneDataIntoFIFO(0x59);	//关闭激光
		m_bLaserOn=false;

//		WriteOneDataIntoFIFO(8); //延迟100毫秒
//		WriteOneDataIntoFIFO(100);

		//正向延长线
/*		GetExtendedLine(P0, P1, P);
		WriteOneDataIntoFIFO(3);
		WriteOneDataIntoFIFO(DWORD((P.m_dX+centerPosX)*500));
		WriteOneDataIntoFIFO(DWORD((P.m_dY+centerPosY)*500));
*/
		spareSpace -= 13;
		m_IPInfo.m_3thIP ++ ;	//修改断点指针
	} //end of polylines

	if(m_IPInfo.GetFlagBit(1))
	{
		if(spareSpace < 7)
			return;

		//关闭激光
		WriteOneDataIntoFIFO(0x59);
	
		//设定回零速度
		WriteOneDataIntoFIFO(7);
		WriteOneDataIntoFIFO(m_pathParam.m_ZeroSpeed);

		//X轴和Y轴回零
		WriteOneDataIntoFIFO(3);
		WriteOneDataIntoFIFO(0);
		WriteOneDataIntoFIFO(0);

		//等待步进电机到位
		WriteOneDataIntoFIFO(-1);

		spareSpace -= 7;
		m_IPInfo.ResetFlagBit(1);	//清除断点标志位
	}

	if(m_IPInfo.GetFlagBit(5))
	{
		if(spareSpace<1)
			return;

		WriteOneDataIntoFIFO(0x80000000); //数据传送完毕
		spareSpace --;
		m_IPInfo.ResetFlagBit(5);	//清除断点标志位
	}
	
	if(!m_IPInfo.GetFlagBit(2))
		m_IPInfo.SetFlagBit(2);	//设置层结束标志
}

void CPathData::WriteOneDataIntoFIFO(DWORD data)
{
	m_pFIFO->WriteFIFO(data);
}

void CPathData::SendDataToController(void)
{
	DWORD dataItem;
	long totalData=m_pFIFO->SizeOfDataInFIFO();
	long spareSpace=_inpd(0x8320)/4;
	long count=totalData > spareSpace ? spareSpace : totalData;

	for(long i=0; i < count; i++)
	{
		if(!m_pFIFO->ReadFIFO(dataItem))
			return;

		if(dataItem == 0x80000000)	//制造过程结束
		{
			m_IPInfo.SetFlagBit(4);
			return;
		}

		_outpd(0x8320,dataItem); 
	}		
}

void CPathData::ClearInstruction( void )
{
	//清指令
	_outp(0x8321,3);

	//关闭激光
	_outpd(0x8320,0x59);
	
	//回零速度: 10m/min
	_outpd(0x8320,7);
	_outpd(0x8320,5000000); 

	//回零
	_outpd(0x8320,3);
	_outpd(0x8320,0);
	_outpd(0x8320,0);
}	

void CPathData::GetExtendedLine(const C2DPoint & p0, const C2DPoint & p1,
								C2DPoint & p, bool dir)
{
	double d1, d2;
	
	d2 = 0.01 * m_pathParam.m_ScanSpeed / 30000.0;	//10ms

	double dx1, dy1;
	double dx2, dy2;
	double cos_a, sin_a;

	dx1 = p1.m_dX - p0.m_dX;
	dy1 = p1.m_dY - p0.m_dY;

	d1 = sqrt(fabs(dx1 * dx1 + dy1 * dy1));

	cos_a = dx1/d1;
	sin_a = dy1/d1;

	if(dir)	//正向延长线
	{
		dx2 = (d1 + d2) * cos_a;
		dy2 = (d1 + d2) * sin_a;

	}
	else	//反向延长线
	{
		dx2 = d2 * (-cos_a);
		dy2 = d2 * (-sin_a);
	}

	p.m_dX = p0.m_dX + dx2;
	p.m_dY = p0.m_dY + dy2;
}