tabtoolsimulate.cpp

这是关于飞机生存力计算软件

							MiniArea.m_fZ = fZMax;
							MiniArea.m_fArea = fXStep * fYStep;
							MiniArea.m_sName = (pTriMeshForIntersection[m]).m_sName;
							pMiniAreaList->InsertNewNodeAtTail(MiniArea);
						}
					}
					
					if(pMiniAreaList->nItemCount() > 0)
					{
						//If there exist at least one node
						pMiniAreaList->SortHighToLow();
						
						pMiniAreaNode = pMiniAreaList->pGetHead();
						pMiniAreaNode = pMiniAreaNode->m_pNext;

						if((pMiniAreaNode->m_Data).m_fArea > 0.000001)
						{
							//If the mini area is not too small to add it in
							bInserted = FALSE;
							pSimulateAreaNode = pSimulateAreaList->pGetHead();
							pSimulateAreaNode = pSimulateAreaNode->m_pNext;
							while(pSimulateAreaNode != NULL)
							{
								//Travel the SimulateArea list
								if((pSimulateAreaNode->m_Data).bCheckMeshNameListUniform(pMiniAreaList))
								{
									//if this mesh name sequence has already existed
									bInserted = TRUE;
									break;
								}
								pSimulateAreaNode = pSimulateAreaNode->m_pNext;
							}

							if(bInserted == FALSE)
							{
								//This must be a new type mesh name list
								//so just insert to the SimulateArea List!
								SimulateArea.CopyFromMiniAreaList(pMiniAreaList);
								pSimulateAreaList->InsertNewNodeAtTail(SimulateArea);
								bInserted = TRUE;
							}
						}
					}
				}
				pPreScanIntersectionPointNode = pScanIntersectionPointNode;
				pScanIntersectionPointNode = pScanIntersectionPointNode->m_pNext;
			}
		}
		m_ProgressBar.StepIt();
	}
	m_ProgressBar.SetPos(0);
	m_ProgressBar.ShowWindow(SW_HIDE);	

	CString TempStr;
	Node<CString>* pStringNode;
	List<CString>* pStringList;
	int nOverlapParts = 0;
	float fTotalArea = 0.0 ;

	if(nUnimportantMeshesItems == 0)
	{
		//Cool! There must exist none unimportant mesh
		//We just need to do a little work
		pSimulateAreaNode = pSimulateAreaList->pGetHead();
		pSimulateAreaNode = pSimulateAreaNode->m_pNext;
		while(pSimulateAreaNode != NULL)
		{
			fTotalArea = fTotalArea + (pSimulateAreaNode->m_Data).m_fArea;
			pSimulateAreaNode = pSimulateAreaNode->m_pNext;
		}
	}
	else
	{
		//There must exist some unimportant meshes, we have to do some extra work!

		//First let's get the total area and "delete" the redundant meshes
		pSimulateAreaNode = pSimulateAreaList->pGetHead();
		pSimulateAreaNode = pSimulateAreaNode->m_pNext;
		
		while(pSimulateAreaNode != NULL)
		{
			fTotalArea = fTotalArea + (pSimulateAreaNode->m_Data).m_fArea;
		
			pStringList = (pSimulateAreaNode->m_Data).m_pMeshNameList;

			//Check if there is some unimportant mesh in the list
			for(i = 0; i < nUnimportantMeshesItems; i++)
			{
				while((pStringNode = pStringList->pFindItem(pUnimportantMeshNameArray[i])) != NULL)
					pStringList->DeleteAfter(pStringNode);
			}
	
			pSimulateAreaNode = pSimulateAreaNode->m_pNext;

		}

		//Now we have delete the redundant meshes
		//But this action may have modified our simulate area list
		//So we have to recheck the simulate area list
		List<CSimulateArea>* pTempSimulateAreaList = new List<CSimulateArea>;
		Node<CSimulateArea>* pTempSimulateAreaNode;
		Node<CString>* pTempStringNode;
		List<CString>* pTempStringList;
		BOOL bUniform;

		pSimulateAreaNode = pSimulateAreaList->pGetHead();
		pSimulateAreaNode = pSimulateAreaNode->m_pNext;

		//Travel the original simulate area list to 
		//insert any node in it
		while(pSimulateAreaNode != NULL)
		{
			pStringList = (pSimulateAreaNode->m_Data).m_pMeshNameList;

			if(pStringList->nItemCount() == 0)
			{
				//If the current simulate area node has no sence
				//just pass it
				pSimulateAreaNode = pSimulateAreaNode->m_pNext;
				continue;
			}

			pTempSimulateAreaNode = pTempSimulateAreaList->pGetHead();
			pTempSimulateAreaNode = pTempSimulateAreaNode->m_pNext;
			
			//Travel the temp simulate area list to find if there exist 
			//a node which has the same mesh sequence
			bInserted = FALSE;
			while(pTempSimulateAreaNode != NULL)
			{
				bUniform = TRUE;
			
				pTempStringList = (pTempSimulateAreaNode->m_Data).m_pMeshNameList;

				//Now let's check pStringList and pTempStringList has the same
				//mesh sequence
				pStringNode = pStringList->pGetHead();
				pStringNode = pStringNode->m_pNext;

				pTempStringNode = pTempStringList->pGetHead();
				pTempStringNode = pTempStringNode->m_pNext;

				while(pStringNode != NULL && pTempStringNode != NULL)
				{
					if(pStringNode->m_Data != pTempStringNode->m_Data)
					{
						bUniform = FALSE;
						break;
					}

					pStringNode = pStringNode->m_pNext;
					pTempStringNode = pTempStringNode->m_pNext;
				}
	
				if(pStringNode == NULL && pTempStringNode == NULL && bUniform == TRUE)
				//if the two list has the same length
				//then they must the same mesh name sequence;
				{
					(pTempSimulateAreaNode->m_Data).m_fArea = (pTempSimulateAreaNode->m_Data).m_fArea + 
																(pSimulateAreaNode->m_Data).m_fArea;
					bInserted = TRUE;
					break;
				}

				pTempSimulateAreaNode = pTempSimulateAreaNode->m_pNext;
			}
			
			if(bInserted == FALSE)
			{
				//Oh this must be a new node, so just insert it the 
				//temp simulate area list
				pTempSimulateAreaList->InsertNewNodeAtTail(pSimulateAreaNode->m_Data);
			}

			pSimulateAreaNode = pSimulateAreaNode->m_pNext;
		}
		
		//Now we'll delete the pointer pSimulateAreaList
		//and let pSimulateAreaList = pTempSimulateAreaList
		delete pSimulateAreaList;
		pSimulateAreaList = pTempSimulateAreaList;	
	}
	
	//Now let's output the datas to the file
	if(bLocalProjection == TRUE)
	//OutPut the sign 1 means local projection
		fprintf(OutPutFile, "1,\n");
	else
	//OutPut the sign 2 means full projection
		fprintf(OutPutFile, "2,\n");

	fprintf(OutPutFile, "%f,\n", fLengthOfDPToWC);

	fprintf(OutPutFile, "%f,\n", fTotalArea);

	fprintf(OutPutFile, "%d,\n", nImportantMeshesItems);

	float * pfAreaOfImportantMeshes = new float [nImportantMeshesItems];
	for(i = 0; i < nImportantMeshesItems; i++)
		pfAreaOfImportantMeshes[i] = 0.0;
	
	pSimulateAreaNode = pSimulateAreaList->pGetHead();
	pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	while(pSimulateAreaNode != NULL)
	{
		pStringList = (pSimulateAreaNode->m_Data).m_pMeshNameList;
		if(pStringList->nItemCount() == 1)
		{
			pStringNode = pStringList->pGetHead();
			pStringNode = pStringNode->m_pNext;

			for(i = 0; i < nImportantMeshesItems; i++)
			{
				if(pImportantMeshNameArray[i] == pStringNode->m_Data)
				{
					//Yes we found it
					pfAreaOfImportantMeshes[i] = (pSimulateAreaNode->m_Data).m_fArea;
					break;
				}
			}
		}

		pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	}

	for(i = 0; i < nImportantMeshesItems; i++)
		fprintf(OutPutFile, "%f,", pfAreaOfImportantMeshes[i]);

	fprintf(OutPutFile, "\n");

	pSimulateAreaNode = pSimulateAreaList->pGetHead();
	pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	while(pSimulateAreaNode != NULL)
	{
		pStringList = (pSimulateAreaNode->m_Data).m_pMeshNameList;
		if(pStringList->nItemCount() > 1)
			nOverlapParts = nOverlapParts + 1;

		pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	}

	fprintf(OutPutFile, "%d,\n", nOverlapParts);

	pSimulateAreaNode = pSimulateAreaList->pGetHead();
	pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	while(pSimulateAreaNode != NULL)
	{
		pStringList = (pSimulateAreaNode->m_Data).m_pMeshNameList;
		if(pStringList->nItemCount() > 1)
			fprintf(OutPutFile, "%f,\n", (pSimulateAreaNode->m_Data).m_fArea);

		pSimulateAreaNode = pSimulateAreaNode->m_pNext;

	}

	pSimulateAreaNode = pSimulateAreaList->pGetHead();
	pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	while(pSimulateAreaNode != NULL)
	{
		pStringList = (pSimulateAreaNode->m_Data).m_pMeshNameList;
		if(pStringList->nItemCount() > 1)
			fprintf(OutPutFile, "%d,\n", pStringList->nItemCount());

		pSimulateAreaNode = pSimulateAreaNode->m_pNext;

	}

	BOOL bFound;
	pSimulateAreaNode = pSimulateAreaList->pGetHead();
	pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	while(pSimulateAreaNode != NULL)
	{
		pStringList = (pSimulateAreaNode->m_Data).m_pMeshNameList;
		if(pStringList->nItemCount() > 1)
		{
			pStringNode = pStringList->pGetHead();
			pStringNode = pStringNode->m_pNext;

			while(pStringNode != NULL)
			{
				bFound = FALSE;
				for(i = 0; i < nImportantMeshesItems; i++)
				{
					if(pImportantMeshNameArray[i] == pStringNode->m_Data)
					{
						//Yes we found it
						fprintf(OutPutFile, "%d,\n", i + 1);
						bFound = TRUE;
						break;
					}
				}
	
				pStringNode = pStringNode->m_pNext;
			}

		}

		pSimulateAreaNode = pSimulateAreaNode->m_pNext;
	}

	fclose(OutPutFile);

	delete [] pTriMeshForIntersection;
	delete pScanIntersectionPointList;
	delete pSimulateAreaList;
	delete pMiniAreaList;
	delete [] pfAreaOfImportantMeshes;

	if(bLocalProjection == TRUE)
	//Return the sign 1 means local projection
		return(1);
	else
	//Return the sign 2 means full projection
		return(2);

}

void CTabtoolSimulate::OnTabtoolSimulateAddall1() 
{
	// TODO: Add your control notification handler code here
	CString sMeshName;
	int nIndex;
	int nItems;
	int nReturnItem;
			
	if((nItems = m_MeshesList1.GetCount()) != LB_ERR)
	{
		for(nIndex = 0; nIndex < nItems; nIndex++)
		{
			m_MeshesList1.GetText(nIndex, sMeshName);
			if(sMeshName.IsEmpty())
				return;
			else
			{
				nReturnItem = m_ImportantMeshesList.AddString(sMeshName);
				if(nReturnItem == LB_ERR || nReturnItem == LB_ERRSPACE)
					return;
			}
		}
		m_MeshesList1.ResetContent();
	}
	
}

void CTabtoolSimulate::OnTabtoolSimulateAddone1() 
{
	// TODO: Add your control notification handler code here
	CString sMeshName;
	int nIndex;
	
	if((nIndex = m_MeshesList1.GetCurSel()) != LB_ERR)
	{
		m_MeshesList1.GetText(nIndex, sMeshName);
		if(sMeshName.IsEmpty())
			return;
		else
		{
			if(m_MeshesList1.DeleteString(nIndex) == LB_ERR)
				return;
			
			nIndex = m_ImportantMeshesList.AddString(sMeshName);
			if(nIndex == LB_ERR || nIndex == LB_ERRSPACE)
				return;
		}
	}
	
}

void CTabtoolSimulate::OnTabtoolSimulateRemoveall1() 
{
	// TODO: Add your control notification handler code here
	CString sMeshName;
	int nIndex;
	int nItems;
	int nReturnItem;
			
	if((nItems = m_ImportantMeshesList.GetCount()) != LB_ERR)
	{
		for(nIndex = 0; nIndex < nItems; nIndex++)
		{
			m_ImportantMeshesList.GetText(nIndex, sMeshName);
			if(sMeshName.IsEmpty())
				return;
			else
			{
				nReturnItem = m_MeshesList1.AddString(sMeshName);
				if(nReturnItem == LB_ERR || nReturnItem == LB_ERRSPACE)
					return;
			}
		}
		m_ImportantMeshesList.ResetContent();
	}
	
}

void CTabtoolSimulate::OnTabtoolSimulateRemoveone1() 
{
	// TODO: Add your control notification handler code here
	CString sMeshName;
	int nIndex;
	
	if((nIndex = m_ImportantMeshesList.GetCurSel()) != LB_ERR)
	{
		m_ImportantMeshesList.GetText(nIndex, sMeshName);
		if(sMeshName.IsEmpty())
			return;
		else
		{
			if(m_ImportantMeshesList.DeleteString(nIndex) == LB_ERR)
				return;
			
			nIndex = m_MeshesList1.AddString(sMeshName);
			if(nIndex == LB_ERR || nIndex == LB_ERRSPACE)
				return;
		}
	}
	
}