dmsv2/Dms/StaticData.cpp

/**************************************************************************************************
                                   版本所有(C), 2020-2022, 北京普达迪泰
***************************************************************************************************
 文 件 名: StaticData.h
 功能描述: Static Task任务报告数据
 版 本 号: 1.00初版
 作    者: HYF
 生成日期; 2021－12－20
 最近修改:
 函数列表:
 修改历史:
     1.日    期 :2021－12－20
       作    者 : HYF
       修改内容 : 创建文件

**************************************************************************************************/
#include "pch.h"
#include <afx.h>
#include <afxtempl.h>
#include "StaticData.h"
#include "EquipDataManager.h"
#include "DictManager.h"
#include "EquipDataPointManager.h"
#include "EquipDataCircleManager.h"
#include "EquipDataPlaneManager.h"
#include "EquipDataLineManager.h"
#include "EquipDataCylinderManager.h"
#include "EquipDataAngleManager.h"
#include "EquipDataPointRelatedManager.h"
#include "EquipData.h"
#include "EquipDataPlane.h"
#include "EquipDataCircle.h"
#include "EquipDataLine.h"
#include "EquipDataPoint.h"
#include "EquipDataCylinder.h"
#include "EquipDataAngle.h"
#include "EquipDataPointRelated.h"
#include "Utils.h"

// StaticData
StaticData::StaticData(DWORD iTaskId, LPCTSTR szEquipTypeCode, LPCTSTR szEquipCode)
: m_iTaskId(iTaskId)
, m_szEquipTypeCode(szEquipTypeCode)
, m_szEquipCode(szEquipCode)
{
	m_pDictManager = new DictManager();
}

StaticData::~StaticData()
{
	if (NULL != m_pDictManager) {
		delete m_pDictManager;
		m_pDictManager = NULL;
	}
}

/**************************************************************************************************
函 数 名 :LoadDataFromFile
功能描述 :从IDPMS报告加载数据
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::LoadDataFromFile(LPCTSTR szFile)
{
    CStdioFile file;
    CFileException e;
    CString szErr;
    CString szFilePath;
    DWORD pos=0;
    
    if (!file.Open(szFile, CFile::typeText|CFile::modeRead))
    {
       LOG::E(_T("静态数据文件打不开"));
       return FALSE;
    }

    int iType = 1;
    int iItemId    = 0;
    int iSubItemId = 0;
    BOOL bRet = TRUE;
    CString szLine;

    while (TRUE) {
        if (!file.ReadString(szLine)) break;

        if ((szLine.Find(_T("点名称")) >= 0) && (iType == 1))
        {
            AddEquipItemData(iType);
            bRet = this->ParsePoint(&file);
            if (!bRet) break;
        }
        else if (szLine.Find(_T("点残差")) >= 0)
        {
            bRet = this->ParsePointRelated(&file, iType);
            if (!bRet) break;
        }
        else if (szLine.Find(_T("平面:")) >= 0)
        {
            iType =  2;
            AddEquipItemData(iType);
            bRet   = this->ParsePlane(&file, szLine);
            if (!bRet) break;
        }
        else if (szLine.Find(_T("Circle:")) >= 0)
        {
            iType =  3;
            AddEquipItemData(iType);
            bRet = this->ParseCircle(&file, szLine);
            if (!bRet) break;
        }
        else if (szLine.Find(_T("直线:")) >= 0)
        {
            iType =  4;
            AddEquipItemData(iType);
            bRet = this->ParseLine(&file, szLine);
            if (!bRet) break;
        }
        else if (szLine.Find(_T("圆柱:")) >= 0)
        {
            iType =  5;
            AddEquipItemData(iType);
            bRet = this->ParseCylinder(&file, szLine);
            if (!bRet) break;
        }
        
    }
    
   // 关闭文件
    file.Close();

    return bRet;
}

/**************************************************************************************************
函 数 名 :ParsePoint
功能描述 :解析Point行
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::ParsePoint(CStdioFile *pFile)
{
    EquipDataPoint *pPoint = NULL;
    CStringArray szArray;
    CString szLine;
    DWORD iSubItemId = 0;

    while (pFile->ReadString(szLine)) {
        if (szLine.IsEmpty()) return TRUE;
        int iNum = Utils::StrSplit(szLine, ' ', szArray);
        if (iNum < 2) continue;
        CString szPointTitle(szArray.GetAt(0));
        CString szPointCode(szArray.GetAt(0));
        CString szPointAX = szArray.GetAt(1);
        CString szPointAY = szArray.GetAt(2);
        CString szPointAZ = szArray.GetAt(3);
		CString szPointTotal = szArray.GetAt(7);

        DOUBLE  pointAX = atof(szPointAX.GetBuffer());
        DOUBLE  pointAY = atof(szPointAY.GetBuffer());
        DOUBLE  pointAZ = atof(szPointAZ.GetBuffer());
		DOUBLE  pointTotal = atof(szPointTotal.GetBuffer());
        
        // SubItemId
        iSubItemId = (DWORD)m_PointList.GetCount() + 1;

        // 新增
        pPoint = new EquipDataPoint();
		pPoint->SetTaskId(m_iTaskId);
        pPoint->SetEquipCode(m_szEquipCode);
        pPoint->SetItemId(1);
        pPoint->SetSubItemId(iSubItemId);
        pPoint->SetPointTitle(m_pDictManager->GetDictItemTitle(szPointCode, szPointCode));
        pPoint->SetPointCode(szPointCode);
        pPoint->SetPointAX(pointAX);
        pPoint->SetPointAY(pointAY);
        pPoint->SetPointAZ(pointAZ);
		pPoint->SetPointTotal(pointTotal);
        m_PointList.AddTail(pPoint);
    } 

    return TRUE;
}

/**************************************************************************************************
函 数 名 :ParsePlane
功能描述 :解析Plane行
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::ParsePlane(CStdioFile *pFile, CString& szTitleLine)
{   
    CStringArray szTitleArray;
    int iNum = Utils::StrSplit(szTitleLine, ' ', szTitleArray);
    CString szPlaneCode(szTitleArray.GetAt(1));

    CStringArray szArray;
    DWORD iSubItemId = (DWORD)m_PlaneList.GetCount()+1;
    CString szLine;

    EquipDataPlane* pPlane = new EquipDataPlane();
   

    while (pFile->ReadString(szLine)) {
        if (szLine.IsEmpty()) break;

        iNum = Utils::StrSplit(szLine, ' ', szArray);
        if (iNum < 2) continue;

        CString szParam = szArray.GetAt(0);
        if (szParam.CompareNoCase("A:") == 0)
        {
            CString szA = szArray.GetAt(1);
            DOUBLE  fA = atof(szA.GetBuffer());
            pPlane->SetPlaneA(fA);
        }
        else if (szParam.CompareNoCase("B:") == 0)
        {
            CString szB = szArray.GetAt(1);
            DOUBLE  fB = atof(szB.GetBuffer());
            pPlane->SetPlaneB(fB);
        }
        else if (szParam.CompareNoCase("C:") == 0)
        {
            CString szC = szArray.GetAt(1);
            DOUBLE  fC  = atof(szC.GetBuffer());
            pPlane->SetPlaneC(fC);
        }
        else if (szParam.CompareNoCase("D:") == 0)
        {
            CString szD = szArray.GetAt(1);
            DOUBLE  fD  = atof(szD.GetBuffer());
            pPlane->SetPlaneD(fD);
        }
        else if (szParam.CompareNoCase("RMS:") == 0)
        {
            CString szRMS = szArray.GetAt(1);
            DOUBLE  fRMS  = atof(szRMS.GetBuffer());
            pPlane->SetPlaneRMS(fRMS);
        }
    } 
	pPlane->SetTaskId(m_iTaskId);
    pPlane->SetEquipCode(m_szEquipCode);
    pPlane->SetPlaneTitle(m_pDictManager->GetDictItemTitle(szPlaneCode, szPlaneCode));
    pPlane->SetPlaneCode(szPlaneCode);
    pPlane->SetItemId(2);
    pPlane->SetSubItemId(iSubItemId);
    m_PlaneList.AddTail(pPlane);

    return TRUE;
}

/**************************************************************************************************
函 数 名 :ParseCircle
功能描述 :解析Circle行
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::ParseCircle(CStdioFile *pFile, CString& szTitleLine )
{
    CStringArray szTitleArray;
    int iNum = Utils::StrSplit(szTitleLine, ' ', szTitleArray);
    CString szCircleCode(szTitleArray.GetAt(1));

    CStringArray szArray;
    CString szLine;
    DWORD iSubItemId = (DWORD)m_CircleList.GetCount()+1;
    EquipDataCircle *pCircle = new EquipDataCircle();

    while (pFile->ReadString(szLine)) {
        if (szLine.IsEmpty()) break;

        iNum = Utils::StrSplit(szLine, ' ', szArray);
        if (iNum < 2) continue;

        CString szParam = szArray.GetAt(0);
        if (szParam.CompareNoCase("中心点:") == 0) {
            CString szCCX = szArray.GetAt(1);
            CString szCCY = szArray.GetAt(2);
            CString szCCZ = szArray.GetAt(3);

            DOUBLE  fCCX = atof(szCCX.GetBuffer());
            DOUBLE  fCCY = atof(szCCY.GetBuffer());
            DOUBLE  fCCZ = atof(szCCZ.GetBuffer());
            pCircle->SetCircleCenterX(fCCX);
            pCircle->SetCircleCenterY(fCCY);
            pCircle->SetCircleCenterZ(fCCZ);
        }
        else if(szParam.CompareNoCase("半径:") == 0)
        {
            CString szRadius = szArray.GetAt(1);
            DOUBLE  fRadius  = atof(szRadius);
            pCircle->SetCircleRadius(fRadius);
        }
        else if(szParam.CompareNoCase("总RMS:") == 0)
        {
            CString szRMS = szArray.GetAt(1);
            DOUBLE  fRMS  = atof(szRMS);
            pCircle->SetCircleRMS(fRMS);
        }
    } 
	pCircle->SetTaskId(m_iTaskId);
    pCircle->SetEquipCode(m_szEquipCode);
    pCircle->SetCircleTitle(m_pDictManager->GetDictItemTitle(szCircleCode, szCircleCode));
    pCircle->SetCircleCode(szCircleCode);
    pCircle->SetItemId(3);
    pCircle->SetSubItemId(iSubItemId);
    m_CircleList.AddTail(pCircle);

    return TRUE;
}


/**************************************************************************************************
函 数 名 :ParseLine
功能描述 :解析Line行
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::ParseLine(CStdioFile *pFile, CString& szTitleLine )
{
    CStringArray szTitleArray;
    int iNum = Utils::StrSplit(szTitleLine, ' ', szTitleArray);
    CString szLineCode(szTitleArray.GetAt(1));
    
    CStringArray szArray;
    CString szLine;
    DWORD iSubItemId = (DWORD)m_LineList.GetCount()+1;
    EquipDataLine *pLine = new EquipDataLine();

    while (pFile->ReadString(szLine)) {
        if (szLine.IsEmpty()) break;

        iNum = Utils::StrSplit(szLine, ' ', szArray);
        if (iNum < 2) continue;

        CString szParam = szArray.GetAt(0);
        if (szParam.CompareNoCase("方向向量:") == 0) {
            CString szVecX  = szArray.GetAt(1);
            CString szVecY  = szArray.GetAt(2);
            CString szVecZ  = szArray.GetAt(3);
            DOUBLE  fVecX   = atof(szVecX.GetBuffer());
            DOUBLE  fVecY   = atof(szVecY.GetBuffer());
            DOUBLE  fVecZ   = atof(szVecZ.GetBuffer());
            pLine->SetLineVectorX(fVecX);
            pLine->SetLineVectorY(fVecY);
            pLine->SetLineVectorZ(fVecZ);
        }
        else if (szParam.CompareNoCase("终点1:") == 0) {
            CString szStartX = szArray.GetAt(1);
            CString szStartY = szArray.GetAt(2);
            CString szStartZ = szArray.GetAt(3);
            DOUBLE  fStartX  = atof(szStartX.GetBuffer());
            DOUBLE  fStartY  = atof(szStartY.GetBuffer());
            DOUBLE  fStartZ  = atof(szStartZ.GetBuffer());
            pLine->SetLineStartX(fStartX);
            pLine->SetLineStartY(fStartY);
            pLine->SetLineStartZ(fStartZ);
        }
        else if (szParam.CompareNoCase("终点2:") == 0) {
            CString szEndX  = szArray.GetAt(1);
            CString szEndY  = szArray.GetAt(2);
            CString szEndZ  = szArray.GetAt(3);
            DOUBLE  fEndX   = atof(szEndX.GetBuffer());
            DOUBLE  fEndY   = atof(szEndY.GetBuffer());
            DOUBLE  fEndZ   = atof(szEndZ.GetBuffer());
            pLine->SetLineEndX(fEndX);
            pLine->SetLineEndY(fEndY);
            pLine->SetLineEndZ(fEndZ);
        }
        else if(szParam.CompareNoCase("长度:") == 0)
        {
            CString szLength = szArray.GetAt(1);
            DOUBLE  fLength  = atof(szLength);
            pLine->SetLineLength(fLength);
        }        
    } 
	pLine->SetTaskId(m_iTaskId);
    pLine->SetEquipCode(m_szEquipCode);
    pLine->SetLineTitle(m_pDictManager->GetDictItemTitle(szLineCode, szLineCode));
    pLine->SetLineCode(szLineCode);
    pLine->SetItemId(4);
    pLine->SetSubItemId(iSubItemId);
    m_LineList.AddTail(pLine);
    return TRUE;
}

/**************************************************************************************************
函 数 名 :ParseCylinder
功能描述 :解析Cylinder行
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::ParseCylinder(CStdioFile *pFile, CString& szTitleLine)
{
    CStringArray szTitleArray;
    int iNum = Utils::StrSplit(szTitleLine, ' ', szTitleArray);
    CString szCylinderCode(szTitleArray.GetAt(1));

    CStringArray szArray;
    CString szLine;
    DWORD iSubItemId = (DWORD)m_CylinderList.GetCount()+1;
    EquipDataCylinder *pCylinder = new EquipDataCylinder();

    while (pFile->ReadString(szLine)) {
        if (szLine.IsEmpty()) break;
        iNum = Utils::StrSplit(szLine, ' ', szArray);

        CString szParam = szArray.GetAt(0);
        if (szParam.CompareNoCase("终点1:") == 0) {
            CString szP1X = szArray.GetAt(1);
            CString szP1Y = szArray.GetAt(2);
            CString szP1Z = szArray.GetAt(3);
            DOUBLE  fP1X = atof(szP1X.GetBuffer());
            DOUBLE  fP1Y = atof(szP1Y.GetBuffer());
            DOUBLE  fP1Z = atof(szP1Z.GetBuffer());
            pCylinder->SetPoint1X(fP1X);
            pCylinder->SetPoint1Y(fP1Y);
            pCylinder->SetPoint1Z(fP1Z);
        }
        else if (szParam.CompareNoCase("终点2:") == 0) {
            CString szP2X = szArray.GetAt(1);
            CString szP2Y = szArray.GetAt(2);
            CString szP2Z = szArray.GetAt(3);
            DOUBLE  fP2X = atof(szP2X.GetBuffer());
            DOUBLE  fP2Y = atof(szP2Y.GetBuffer());
            DOUBLE  fP2Z = atof(szP2Z.GetBuffer());
            pCylinder->SetPoint2X(fP2X);
            pCylinder->SetPoint2Y(fP2Y);
            pCylinder->SetPoint2Z(fP2Z);
        }
        else if(szParam.CompareNoCase("半径:") == 0)
        {
            CString szRadius = szArray.GetAt(1);
            DOUBLE  fRadius  = atof(szRadius);
            pCylinder->SetCylinderRadius(fRadius);
        }
        else if(szParam.CompareNoCase("长度:") == 0)
        {
            CString szLength = szArray.GetAt(1);
            DOUBLE  fLength  = atof(szLength.GetBuffer());
            pCylinder->SetCylinderLength(fLength);
        }
    } 
	pCylinder->SetTaskId(m_iTaskId);
    pCylinder->SetEquipCode(m_szEquipCode);
    pCylinder->SetCylinderTitle(m_pDictManager->GetDictItemTitle(szCylinderCode, szCylinderCode));
    pCylinder->SetCylinderCode(szCylinderCode);
    pCylinder->SetItemId(5);
    pCylinder->SetSubItemId(iSubItemId);

    m_CylinderList.AddTail(pCylinder);

    return TRUE;
}

void StaticData::AddAngle(EquipDataAngle *pNewAngle)
{
	DWORD iSubItemId = (DWORD)m_AngleList.GetCount();
	pNewAngle->SetSubItemId(iSubItemId+1);
	m_AngleList.AddTail(pNewAngle);
}

/**************************************************************************************************
函 数 名 :ParsePointRelated
功能描述 :解析点残差
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::ParsePointRelated(CStdioFile *pFile,  int iType)
{
    switch (iType) {
        case 2:
			this->ParsePlanePointRelated(pFile);
            break;

        case 3:
			this->ParseCirclePointRelated(pFile);
            break;

        case 4:
			this->ParseLinePointRelated(pFile);
            break;

        case 5:
			this->ParseCylinderPointRelated(pFile);
            break;
    }
    return TRUE;
}

// Plane Points related Parser
BOOL StaticData::ParsePlanePointRelated(CStdioFile *pFile) {

	EquipDataPointRelated *pPointRelated = NULL;
	CStringArray szArray;
	CString szLine;
	int iItemId = 2;
	int iSubItemId;

	iSubItemId = (int)m_PlaneList.GetCount();

	while (pFile->ReadString(szLine)) {
		if (szLine.IsEmpty()) return TRUE;
		int iNum = Utils::StrSplit(szLine, ' ', szArray);
		CString szPointCode(szArray.GetAt(0));

		if ((iNum < 2) || (szPointCode.Compare("点名称") == 0)) continue;

		CString szPointTitle(szArray.GetAt(0));
		CString szPointAX = szArray.GetAt(1);
		CString szPointAY = szArray.GetAt(2);
		CString szPointAZ = szArray.GetAt(3);
		CString szDX = szArray.GetAt(4);
		CString szDY = szArray.GetAt(5);
		CString szDZ = szArray.GetAt(6);
		CString szTotal = szArray.GetAt(7);
		CString szOffset = szArray.GetAt(8);

		DOUBLE  fPointAX = atof(szPointAX.GetBuffer());
		DOUBLE  fPointAY = atof(szPointAY.GetBuffer());
		DOUBLE  fPointAZ = atof(szPointAZ.GetBuffer());
		DOUBLE  fDX = atof(szDX.GetBuffer());
		DOUBLE  fDY = atof(szDY.GetBuffer());
		DOUBLE  fDZ = atof(szDZ.GetBuffer());
		DOUBLE  fTotal = atof(szTotal.GetBuffer());
		DOUBLE  fOffset = atof(szOffset.GetBuffer());

		// 1.查询点数据是否存在，如果不存在则保存
		EquipDataPoint *pPoint = this->SearchPointByCode(szPointCode);
		DWORD iPointSubItemId;
		if (!pPoint)
		{
			iPointSubItemId = (DWORD)m_PointList.GetCount() + 1;
			EquipDataPoint *pPoint = new EquipDataPoint();
			pPoint->SetItemId(1);
			pPoint->SetTaskId(m_iTaskId);
			pPoint->SetEquipCode(m_szEquipCode);
			pPoint->SetSubItemId(iPointSubItemId);
			pPoint->SetPointTitle(m_pDictManager->GetDictItemTitle(szPointCode, szPointCode));
			pPoint->SetPointCode(szPointCode);
			pPoint->SetPointAX(fPointAX);
			pPoint->SetPointAY(fPointAY);
			pPoint->SetPointAZ(fPointAZ);
			m_PointList.AddTail(pPoint);
		}
		else
		{
			iPointSubItemId = pPoint->GetSubItemId();
		}

		// 2.新增点列差到列表中
		pPointRelated = new EquipDataPointRelated();
		pPointRelated->SetTaskId(m_iTaskId);
		pPointRelated->SetEquipCode(m_szEquipCode);
		pPointRelated->SetItemId(iItemId);
		pPointRelated->SetSubItemId(iSubItemId);
		pPointRelated->SetItemType(2);
		pPointRelated->SetPointSubItemId(iPointSubItemId);
		pPointRelated->SetDX(fDX);
		pPointRelated->SetDY(fDY);
		pPointRelated->SetDZ(fDZ);
		pPointRelated->SetTotal(fTotal);
		pPointRelated->SetOffset(fOffset);
		m_PointRelatedList.AddTail(pPointRelated);
	}

	return TRUE;
}

// Circle Points related Parser
BOOL StaticData::ParseCirclePointRelated(CStdioFile *pFile) {
	EquipDataPointRelated *pPointRelated = NULL;
	CStringArray szArray;
	CString szLine;
	int iItemId = 3;
	int iSubItemId;

	iSubItemId = (int)m_CircleList.GetCount();

	while (pFile->ReadString(szLine)) {
		if (szLine.IsEmpty()) return TRUE;
		int iNum = Utils::StrSplit(szLine, ' ', szArray);
		CString szPointCode(szArray.GetAt(0));

		if ((iNum < 2) || (szPointCode.Compare("点名称") == 0)) continue;

		CString szPointTitle(szArray.GetAt(0));
		CString szPointAX = szArray.GetAt(1);
		CString szPointAY = szArray.GetAt(2);
		CString szPointAZ = szArray.GetAt(3);
		CString szDX = szArray.GetAt(4);
		CString szDY = szArray.GetAt(5);
		CString szDZ = szArray.GetAt(6);
		CString szOnPlane = szArray.GetAt(7);
		CString szOutPlane = szArray.GetAt(8);
		CString szTotal = szArray.GetAt(9);
		CString szOffset = szArray.GetAt(10);

		DOUBLE  fPointAX = atof(szPointAX.GetBuffer());
		DOUBLE  fPointAY = atof(szPointAY.GetBuffer());
		DOUBLE  fPointAZ = atof(szPointAZ.GetBuffer());
		DOUBLE  fDX = atof(szDX.GetBuffer());
		DOUBLE  fDY = atof(szDY.GetBuffer());
		DOUBLE  fDZ = atof(szDZ.GetBuffer());
		DOUBLE  fOnPlane = atof(szOnPlane.GetBuffer());
		DOUBLE  fOutPlane = atof(szOutPlane.GetBuffer());
		DOUBLE  fTotal = atof(szTotal.GetBuffer());
		DOUBLE  fOffset = atof(szOffset.GetBuffer());

		// 1.查询点数据是否存在，如果不存在则保存
		EquipDataPoint *pPoint = this->SearchPointByCode(szPointCode);
		DWORD iPointSubItemId;
		if (!pPoint)
		{
			iPointSubItemId = (DWORD)m_PointList.GetCount() + 1;
			EquipDataPoint *pPoint = new EquipDataPoint();
			pPoint->SetTaskId(m_iTaskId);
			pPoint->SetItemId(1);
			pPoint->SetEquipCode(m_szEquipCode);
			pPoint->SetSubItemId(iPointSubItemId);
			pPoint->SetPointTitle(szPointTitle);
			pPoint->SetPointCode(szPointCode);
			pPoint->SetPointAX(fPointAX);
			pPoint->SetPointAY(fPointAY);
			pPoint->SetPointAZ(fPointAZ);
			m_PointList.AddTail(pPoint);
		}
		else
		{
			iPointSubItemId = pPoint->GetSubItemId();
		}

		// 2.新增点列差到列表中
		pPointRelated = new EquipDataPointRelated();
		pPointRelated->SetTaskId(m_iTaskId);
		pPointRelated->SetEquipCode(m_szEquipCode);
		pPointRelated->SetItemId(iItemId);
		pPointRelated->SetSubItemId(iSubItemId);
		pPointRelated->SetItemType(3);
		pPointRelated->SetPointSubItemId(iPointSubItemId);
		pPointRelated->SetDX(fDX);
		pPointRelated->SetDY(fDY);
		pPointRelated->SetDZ(fDZ);
		pPointRelated->SetOnPlane(fOnPlane);
		pPointRelated->SetOutPlane(fOutPlane);
		pPointRelated->SetTotal(fTotal);
		pPointRelated->SetOffset(fOffset);
		m_PointRelatedList.AddTail(pPointRelated);
	}

	return TRUE;
}

// Line Points related Parser
BOOL StaticData::ParseLinePointRelated(CStdioFile *pFile) {
	EquipDataPointRelated *pPointRelated = NULL;
	CStringArray szArray;
	CString szLine;
	int iItemId = 4;
	int iSubItemId;

	iSubItemId = (int)m_LineList.GetCount();

	while (pFile->ReadString(szLine)) {
		if (szLine.IsEmpty()) return TRUE;
		int iNum = Utils::StrSplit(szLine, ' ', szArray);
		CString szPointCode(szArray.GetAt(0));

		if ((iNum < 2) || (szPointCode.Compare("点名称") == 0)) continue;

		CString szPointTitle(szArray.GetAt(0));
		CString szPointAX = szArray.GetAt(1);
		CString szPointAY = szArray.GetAt(2);
		CString szPointAZ = szArray.GetAt(3);
		CString szDX = szArray.GetAt(4);
		CString szDY = szArray.GetAt(5);
		CString szDZ = szArray.GetAt(6);
		CString szTotal = szArray.GetAt(7);
		CString szOffset = szArray.GetAt(8);

		DOUBLE  fPointAX = atof(szPointAX.GetBuffer());
		DOUBLE  fPointAY = atof(szPointAY.GetBuffer());
		DOUBLE  fPointAZ = atof(szPointAZ.GetBuffer());
		DOUBLE  fDX = atof(szDX.GetBuffer());
		DOUBLE  fDY = atof(szDY.GetBuffer());
		DOUBLE  fDZ = atof(szDZ.GetBuffer());
		DOUBLE  fTotal = atof(szTotal.GetBuffer());
		DOUBLE  fOffset = atof(szOffset.GetBuffer());

		// 1.查询点数据是否存在，如果不存在则保存
		EquipDataPoint *pPoint = this->SearchPointByCode(szPointCode);
		DWORD iPointSubItemId;
		if (!pPoint)
		{
			iPointSubItemId = (DWORD)m_PointList.GetCount() + 1;
			EquipDataPoint *pPoint = new EquipDataPoint();
			pPoint->SetTaskId(m_iTaskId);
			pPoint->SetItemId(1);
			pPoint->SetEquipCode(m_szEquipCode);
			pPoint->SetSubItemId(iPointSubItemId);
			pPoint->SetPointTitle(szPointTitle);
			pPoint->SetPointCode(szPointCode);
			pPoint->SetPointAX(fPointAX);
			pPoint->SetPointAY(fPointAY);
			pPoint->SetPointAZ(fPointAZ);
			m_PointList.AddTail(pPoint);
		}
		else
		{
			iPointSubItemId = pPoint->GetSubItemId();
		}

		// 2.新增点列差到列表中
		pPointRelated = new EquipDataPointRelated();
		pPointRelated->SetTaskId(m_iTaskId);
		pPointRelated->SetEquipCode(m_szEquipCode);
		pPointRelated->SetItemId(iItemId);
		pPointRelated->SetSubItemId(iSubItemId);
		pPointRelated->SetItemType(4);
		pPointRelated->SetPointSubItemId(iPointSubItemId);
		pPointRelated->SetDX(fDX);
		pPointRelated->SetDY(fDY);
		pPointRelated->SetDZ(fDZ);
		pPointRelated->SetTotal(fTotal);
		pPointRelated->SetOffset(fOffset);
		m_PointRelatedList.AddTail(pPointRelated);
	}

	return TRUE;
}

// Cylinder Points related Parser
BOOL StaticData::ParseCylinderPointRelated(CStdioFile *pFile) {
	EquipDataPointRelated *pPointRelated = NULL;
	CStringArray szArray;
	CString szLine;
	int iItemId = 5;
	int iSubItemId;

	iSubItemId = (int)m_CylinderList.GetCount();

	while (pFile->ReadString(szLine)) {
		if (szLine.IsEmpty()) return TRUE;
		int iNum = Utils::StrSplit(szLine, ' ', szArray);
		CString szPointCode(szArray.GetAt(0));

		if ((iNum < 2) || (szPointCode.Compare("点名称") == 0)) continue;

		CString szPointTitle(szArray.GetAt(0));
		CString szPointAX = szArray.GetAt(1);
		CString szPointAY = szArray.GetAt(2);
		CString szPointAZ = szArray.GetAt(3);
		CString szDX = szArray.GetAt(4);
		CString szDY = szArray.GetAt(5);
		CString szDZ = szArray.GetAt(6);
		CString szTotal = szArray.GetAt(7);
		CString szOffset = szArray.GetAt(8);

		DOUBLE  fPointAX = atof(szPointAX.GetBuffer());
		DOUBLE  fPointAY = atof(szPointAY.GetBuffer());
		DOUBLE  fPointAZ = atof(szPointAZ.GetBuffer());
		DOUBLE  fDX = atof(szDX.GetBuffer());
		DOUBLE  fDY = atof(szDY.GetBuffer());
		DOUBLE  fDZ = atof(szDZ.GetBuffer());
		DOUBLE  fTotal = atof(szTotal.GetBuffer());
		DOUBLE  fOffset = atof(szOffset.GetBuffer());

		// 1.查询点数据是否存在，如果不存在则保存
		EquipDataPoint *pPoint = this->SearchPointByCode(szPointCode);
		DWORD iPointSubItemId;
		if (!pPoint)
		{
			iPointSubItemId = (DWORD)m_PointList.GetCount() + 1;
			EquipDataPoint *pPoint = new EquipDataPoint();
			pPoint->SetTaskId(m_iTaskId);
			pPoint->SetItemId(1);
			pPoint->SetEquipCode(m_szEquipCode);
			pPoint->SetSubItemId(iPointSubItemId);
			pPoint->SetPointTitle(szPointTitle);
			pPoint->SetPointCode(szPointCode);
			pPoint->SetPointAX(fPointAX);
			pPoint->SetPointAY(fPointAY);
			pPoint->SetPointAZ(fPointAZ);
			m_PointList.AddTail(pPoint);
		}
		else
		{
			iPointSubItemId = pPoint->GetSubItemId();
		}

		// 2.新增点列差到列表中
		pPointRelated = new EquipDataPointRelated();
		pPointRelated->SetTaskId(m_iTaskId);
		pPointRelated->SetEquipCode(m_szEquipCode);
		pPointRelated->SetItemId(iItemId);
		pPointRelated->SetSubItemId(iSubItemId);
		pPointRelated->SetItemType(5);
		pPointRelated->SetPointSubItemId(iPointSubItemId);
		pPointRelated->SetDX(fDX);
		pPointRelated->SetDY(fDY);
		pPointRelated->SetDZ(fDZ);
		pPointRelated->SetTotal(fTotal);
		pPointRelated->SetOffset(fOffset);
		m_PointRelatedList.AddTail(pPointRelated);
	}

	return TRUE;
}

/**************************************************************************************************
函 数 名 :SearchPointByCode
功能描述 :基于编号查询
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
EquipDataPoint* StaticData::SearchPointByCode(LPCTSTR szCode)
{
    POSITION   pos;
    EquipDataPoint *pPoint = NULL;

	pos = m_PointList.GetHeadPosition();
	while (pos != NULL)
	{
		pPoint = (EquipDataPoint *)m_PointList.GetNext(pos);
		if (pPoint != NULL)
		{
		    CString szPointCode = pPoint->GetPointCode();
            if (szPointCode.Compare(szCode) == 0)
            {
                return pPoint;
            }
		}
	}

    return NULL;
}

/**************************************************************************************************
函 数 名 :SearchPointByCode
功能描述 :基于编号查询
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::IsEquipDataExist(int iType)
{
    POSITION   pos;
    EquipData *pData = NULL;
    BOOL bRet = TRUE;

	pos = m_DataList.GetHeadPosition();
	while (pos != NULL)
	{
		pData = (EquipData *)m_DataList.GetNext(pos);
		if (pData != NULL)
		{
            if ( pData->GetItemType() == iType)
            {
                return TRUE;
            }
		}
	}

    return FALSE;
}


/**************************************************************************************************
函 数 名 :AddEquipItemData
功能描述 :添加数据项到结构中
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::AddEquipItemData(int iType)
{
    EquipData *pEquipData = NULL;
    if (IsEquipDataExist(iType)) return;

    pEquipData = new EquipData();
	pEquipData->SetTaskId(m_iTaskId);
    pEquipData->SetEquipCode(m_szEquipCode);
    pEquipData->SetItemType(iType);
    pEquipData->SetItemId(iType);
    if (iType == 1)
    {
        pEquipData->SetItemCode("Point");
        pEquipData->SetItemTitle("Point");
        pEquipData->SetItemDesc("Point");
    }
    else if (iType == 2) {
        pEquipData->SetItemCode("Plane");
        pEquipData->SetItemTitle("Plane");
        pEquipData->SetItemDesc("Plane");
    }
    else if (iType == 3)
    {
        pEquipData->SetItemCode("Circle");
        pEquipData->SetItemTitle("Circle");
        pEquipData->SetItemDesc("Circle");
    }
    else if (iType == 4)
    {
        pEquipData->SetItemCode("Line");
        pEquipData->SetItemTitle("Line");
        pEquipData->SetItemDesc("Line");
    }
    else if (iType == 5)
    {
        pEquipData->SetItemCode("Cylinder");
        pEquipData->SetItemTitle("Cylinder");
        pEquipData->SetItemDesc("Cylinder");
    }

    m_DataList.AddTail((EquipData *)pEquipData);  
}

/**************************************************************************************************
函 数 名 :AddEquipSubItemData
功能描述 :添加子项数据到结构中
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::AddEquipSubItemData(int iType, void *pData)
{
    if (iType == 1)
    {
        m_PointList.AddTail((EquipDataPoint *)pData);
    }
    else if (iType == 2) 
    {
        m_PlaneList.AddTail((EquipDataPlane *)pData); 
    }
    else if (iType == 3)
    {
        m_CircleList.AddTail((EquipDataCircle *)pData); 
    }
    else if (iType == 4)
    {
        m_LineList.AddTail((EquipDataLine *)pData); 
    }
    else if (iType == 5)
    {
        m_CylinderList.AddTail((EquipDataCylinder *)pData); 
    }
    else if (iType == 6) // 点残差数据
    {
        
    }
}

/**************************************************************************************************
函 数 名 :Clear
功能描述 :清空数据
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::Clear()
{
    while (!m_DataList.IsEmpty())
	{
		delete m_DataList.RemoveHead();
	}

    while (!m_PointList.IsEmpty())
	{
		delete m_PointList.RemoveHead();
	}

    while (!m_PlaneList.IsEmpty())
	{
		delete m_PlaneList.RemoveHead();
	}

    while (!m_CircleList.IsEmpty())
	{
		delete m_CircleList.RemoveHead();
	}

    while (!m_LineList.IsEmpty())
	{
		delete m_LineList.RemoveHead();
	}

    while (!m_CylinderList.IsEmpty())
	{
		delete m_CylinderList.RemoveHead();
	}

	while (!m_AngleList.IsEmpty())
	{
		delete m_AngleList.RemoveHead();
	}

    while (!m_PointRelatedList.IsEmpty())
	{
		delete m_PointRelatedList.RemoveHead();
	}
}

/**************************************************************************************************
函 数 名 :CalcPointFlatness
功能描述 :计算平面度
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::CalcPointFlatness()
{
	EquipDataPlane *pPlane = NULL;
	POSITION pos1;

	pos1 = m_PlaneList.GetHeadPosition();
	while (pos1 != NULL)
	{
		pPlane = (EquipDataPlane *)m_PlaneList.GetNext(pos1);
		if (pPlane != NULL)
		{
			DWORD itemId1 = pPlane->GetItemId();
			DWORD subItemId1 = pPlane->GetSubItemId();
			EquipDataPointRelated *pPointRelated = NULL;

			DOUBLE fMax = 0.0;
			DOUBLE fMin = 0.0;

			// 1.获取结点
			POSITION pos2;
			pos2 = m_PointRelatedList.GetHeadPosition();
			while (pos2 != NULL)
			{
				pPointRelated = (EquipDataPointRelated *)m_PointRelatedList.GetNext(pos2);
				if (pPointRelated != NULL)
				{
					DWORD itemId2 = pPointRelated->GetItemId();
					DWORD subItemId2 = pPointRelated->GetSubItemId();
					DWORD pointId1 = pPointRelated->GetPointSubItemId();
					DWORD  itemType = pPointRelated->GetItemType();
					if ((itemType == 2)&&(itemId1 == itemId2) && (subItemId1 == subItemId2))
					{
						DOUBLE fTotal = pPointRelated->GetTotal();
						if (fTotal > fMax) fMax = fTotal;
						if (fTotal < fMin) fMin = fTotal;
					}
				}
			}

			// 平面度 = 点总计最大值 - 点总计最小值
			pPlane->SetPlaneFlatness(fMax - fMin);
		}
	}
	return;
}

/**************************************************************************************************
函 数 名 :CalcPointFlatness
功能描述 :计算圆度
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::CalcCircleRoundness()
{
	EquipDataCircle *pCircle = NULL;
	POSITION pos1;

	pos1 = m_CircleList.GetHeadPosition();
	while (pos1 != NULL)
	{
		pCircle = (EquipDataCircle *)m_CircleList.GetNext(pos1);
		if (pCircle != NULL)
		{
			DWORD itemId1 = pCircle->GetItemId();
			DWORD subItemId1 = pCircle->GetSubItemId();
			EquipDataPointRelated *pPointRelated = NULL;

			DOUBLE fMax = 0.0;
			DOUBLE fMin = 0.0;

			// 1.获取结点
			POSITION pos2;
			pos2 = m_PointRelatedList.GetHeadPosition();
			while (pos2 != NULL)
			{
				pPointRelated = (EquipDataPointRelated *)m_PointRelatedList.GetNext(pos2);
				if (pPointRelated != NULL)
				{
					DWORD itemId2 = pPointRelated->GetItemId();
					DWORD subItemId2 = pPointRelated->GetSubItemId();
					DWORD pointId1 = pPointRelated->GetPointSubItemId();
					DWORD iItemType = pPointRelated->GetItemType();
					if ((iItemType == 3 )&&(itemId1 == itemId2) && (subItemId1 == subItemId2))
					{
						DOUBLE fOnPlane = pPointRelated->GetOnPlane();
						if (fOnPlane > fMax) fMax = fOnPlane;
						if (fOnPlane < fMin) fMin = fOnPlane;
					}
				}
			}

			// 圆度 = 点总计最大值 - 点总计最小值
			pCircle->SetCircleRoundness(fMax - fMin);
		}
	}
	return;
}

/**************************************************************************************************
函 数 名 :GetAngleParam
功能描述 :新增推力线偏角
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::GenerateAngle()
{
	CString szCylinderCode = AppConfig::GetString("Static", "Cylinder");
	CString szPointCode = AppConfig::GetString("Static", "Point1");
	//this->HandleAngle("cl1", "CODE489");
	this->HandleAngle(szCylinderCode, szPointCode);
}

/**************************************************************************************************
函 数 名 :GetAngleParam
功能描述 :新增推力线偏角
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::GenerateAngleText()
{
	int i = 1;
	CString Cylinder;
	CString Point;
	while (i < 5) {
		Cylinder.Format("Cylinder%d", i);
		Point.Format("Point%d", i);
  	    CString szCylinderCode = AppConfig::GetString("Static", Cylinder);
	    CString szPointCode = AppConfig::GetString("Static", Point);
	    this->HandleAngle(szCylinderCode, szPointCode);
	    i++;
	}
}


/**************************************************************************************************
函 数 名 :GenerateDoublePoint
功能描述 :新增两点式推力线偏角
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::GenerateDoublePoint()
{
	int i = 1;
	CString StartPoint;
	CString EndPoint;
	while (i < 5) {
		StartPoint.Format("SPoint%d", i);
		EndPoint.Format("EPoint%d", i);
		CString szPointCodeStart = AppConfig::GetString("Static", StartPoint);
		CString szPointCodeEnd = AppConfig::GetString("Static", EndPoint);
		this->HandleAngleDoublePoint(szPointCodeStart, szPointCodeEnd);
		i++;
	}
	
}

/**************************************************************************************************
函 数 名 :GetAngleParam
功能描述 :新增推力线偏角
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::HandleAngle(LPCTSTR szTargetCylinderCode, LPCTSTR szTargetPointCode)
{
	DOUBLE x1 = 0.0;
	DOUBLE y1 = 0.0;
	DOUBLE z1 = 0.0;
	DOUBLE x2 = 0.0;
	DOUBLE y2 = 0.0;
	DOUBLE z2 = 0.0;
	CString m_linecode;
	CString m_pointcode;
	bool bExist = false;

	// 1. Cylinder
	POSITION pos1;
	EquipDataCylinder *pCylinder = NULL;
	pos1 = m_CylinderList.GetHeadPosition();
	while (pos1 != NULL)
	{
		pCylinder = (EquipDataCylinder *)m_CylinderList.GetNext(pos1);
		if (pCylinder == NULL) break;
		CString szCylinderCode = pCylinder->GetCylinderCode();
		if (szCylinderCode.Compare(szTargetCylinderCode) == 0)
		{
			DOUBLE point1x = pCylinder->GetPoint1X();
			DOUBLE point1y = pCylinder->GetPoint1Y();
			DOUBLE point1z = pCylinder->GetPoint1Z();
			DOUBLE point2x = pCylinder->GetPoint2X();
			DOUBLE point2y = pCylinder->GetPoint2Y();
			DOUBLE point2z = pCylinder->GetPoint2Z();

			x1 = (point1x + point2x) / 2;
			y1 = (point1y + point2y) / 2;
			z1 = (point1z + point2z) / 2;
			bExist = true;
			break;
		}
	}

	if (!bExist) return;

	// 2.Point
	POSITION pos2;
	EquipDataPoint *pPoint = NULL;
	pos2 = m_PointList.GetHeadPosition();
	while (pos2 != NULL)
	{
		pPoint = (EquipDataPoint *)m_PointList.GetNext(pos2);
		if (pPoint == NULL) break;

		CString szPointCode = pPoint->GetPointCode();
		if (szPointCode.Compare(szTargetPointCode) == 0)
		{
			x2 = pPoint->GetPointAX();
			y2 = pPoint->GetPointAY();
			z2 = pPoint->GetPointAZ();
			break;
		}
	}
	m_linecode.Format("%s & %s", szTargetCylinderCode, szTargetPointCode);
	m_pointcode.Format("%sO", szTargetCylinderCode);

	//3.
	DWORD iTaskId = pPoint->GetTaskId();
	CString szEquipCode = pPoint->GetEquipCode();
	DWORD iPointSubItemId = m_PointList.GetCount()+1;
	DWORD iCylinderSubItemId = pCylinder->GetSubItemId();

	EquipDataPoint *pCyCenter = new EquipDataPoint();
	pCyCenter->SetTaskId(iTaskId);
	pCyCenter->SetEquipCode(szEquipCode);
	pCyCenter->SetItemId(1);
	pCyCenter->SetSubItemId(iPointSubItemId);
	pCyCenter->SetPointCode(m_pointcode);
	pCyCenter->SetPointTitle(m_pointcode);
	pCyCenter->SetPointAX(x1);
	pCyCenter->SetPointAY(y1);
	pCyCenter->SetPointAZ(z1);
	pCyCenter->SetPointEX(0.0);
	pCyCenter->SetPointEY(0.0);
	pCyCenter->SetPointEZ(0.0);
	pCyCenter->SetPointDesc("");
	m_PointList.AddTail(pCyCenter);

	//4.
	EquipDataPointRelated* pCyRelated = new EquipDataPointRelated();
	pCyRelated->SetTaskId(iTaskId);
	pCyRelated->SetEquipCode(szEquipCode);
	pCyRelated->SetItemId(5);
	pCyRelated->SetItemType(5);
	pCyRelated->SetSubItemId(iCylinderSubItemId);
	pCyRelated->SetPointSubItemId(iPointSubItemId);
	pCyRelated->SetDX(0.0);
	pCyRelated->SetDY(0.0);
	pCyRelated->SetDZ(0.0);
	pCyRelated->SetTotal(0.0);
	pCyRelated->SetOffset(0.0);
	pCyRelated->SetOnPlane(0.0);
	pCyRelated->SetOutPlane(0.0);
	m_PointRelatedList.AddTail(pCyRelated);

	if (x1 != 0 && x2 != 0)
	{
		this->CalcAngle(m_linecode,x1, y1, z1, x2, y2, z2);
	}

	return;
}
/**************************************************************************************************
函 数 名 :GetAngleParam
功能描述 :新增推力线偏角两点式
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::HandleAngleDoublePoint(LPCTSTR szPointCodeStart, LPCTSTR szPointCodeEnd)
{
	DOUBLE x1 = 0.0;
	DOUBLE y1 = 0.0;
	DOUBLE z1 = 0.0;
	DOUBLE x2 = 0.0;
	DOUBLE y2 = 0.0;
	DOUBLE z2 = 0.0;
	CString count;

	// 1. PointStart
	POSITION pos1;
	EquipDataPoint *pPoint = NULL;
	pos1 = m_PointList.GetHeadPosition();
	while (pos1 != NULL)
	{
		pPoint = (EquipDataPoint *)m_PointList.GetNext(pos1);
		if (pPoint == NULL) break;

		CString szPointCode = pPoint->GetPointCode();
		if (szPointCode.Compare(szPointCodeStart) == 0)
		{
			x1 = pPoint->GetPointAX();
			y1 = pPoint->GetPointAY();
			z1 = pPoint->GetPointAZ();
		}
	}

	// 2.PointEnd
	POSITION pos2;
	EquipDataPoint *pPoint1 = NULL;
	pos2 = m_PointList.GetHeadPosition();
	while (pos2 != NULL)
	{
		pPoint1 = (EquipDataPoint *)m_PointList.GetNext(pos2);
		if (pPoint1 == NULL) break;

		CString szPointCode = pPoint1->GetPointCode();
		if (szPointCode.Compare(szPointCodeEnd) == 0)
		{
			x2 = pPoint1->GetPointAX();
			y2 = pPoint1->GetPointAY();
			z2 = pPoint1->GetPointAZ();
		}
	}
	count.Format("%s And %s", szPointCodeStart, szPointCodeEnd);

	if (x1 != 0 && x2 != 0)
	{
		this->CalcAngle(count,x1, y1, z1, x2, y2, z2);
	}

	return;
}
/**************************************************************************************************
函 数 名 :CalcAngle
功能描述 :计算推力线偏角
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::CalcAngle(DOUBLE x1, DOUBLE y1, DOUBLE z1, DOUBLE x2, DOUBLE y2, DOUBLE z2) 
{
	// 1.获取坐标值
	DOUBLE fX1 = x1;
	DOUBLE fY1 = y1;
	DOUBLE fZ1 = z1;

	DOUBLE fX2 = x2;
	DOUBLE fY2 = y2;
	DOUBLE fZ2 = z2;

	// 2.计算偏角数据
	DOUBLE v1 = (fX2 - fX1)*(fX2 - fX1);
	DOUBLE v2 = (fY2 - fY1)*(fY2 - fY1);
	DOUBLE v3 = (fZ2 - fZ1)*(fZ2 - fZ1);

	DOUBLE fLength = sqrt(v1 + v2 + v3);
	DOUBLE ax = acos((fX2 - fX1) / fLength) * 180 / PI;
	DOUBLE ay = acos((fY2 - fY1) / fLength) * 180 / PI;
	DOUBLE az = acos((fZ2 - fZ1) / fLength) * 180 / PI;

	// 3. 存储数据
	EquipDataAngle *pAngle = new EquipDataAngle();
	pAngle->SetEquipCode(m_szEquipCode);
	pAngle->SetItemId(6); //
	pAngle->SetLineTitle("AS1AE1");
	pAngle->SetLineCode("AS1AE1");
	pAngle->SetLineStartX(fX1);
	pAngle->SetLineStartY(fY1);
	pAngle->SetLineStartZ(fZ1);
	pAngle->SetLineEndX(fX2);
	pAngle->SetLineEndY(fY2);
	pAngle->SetLineEndZ(fZ2);
	pAngle->SetAngleAX(ax);
	pAngle->SetAngleAY(ay);
	pAngle->SetAngleAZ(az);

	this->AddAngle(pAngle);

	return;
}

/**************************************************************************************************
函 数 名 :CalcAngle
功能描述 :计算推力线偏角有推力线名
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::CalcAngle(CString count,DOUBLE x1, DOUBLE y1, DOUBLE z1, DOUBLE x2, DOUBLE y2, DOUBLE z2)
{
	//0.获取推力线编号
	CString fcount = count;

	// 1.获取坐标值
	DOUBLE fX1 = x1;
	DOUBLE fY1 = y1;
	DOUBLE fZ1 = z1;

	DOUBLE fX2 = x2;
	DOUBLE fY2 = y2;
	DOUBLE fZ2 = z2;

	// 2.计算偏角数据
	DOUBLE v1 = (fX2 - fX1)*(fX2 - fX1);
	DOUBLE v2 = (fY2 - fY1)*(fY2 - fY1);
	DOUBLE v3 = (fZ2 - fZ1)*(fZ2 - fZ1);

	DOUBLE fLength = sqrt(v1 + v2 + v3);
	DOUBLE ax = acos((fX2 - fX1) / fLength) * 180 / PI;
	DOUBLE ay = acos((fY2 - fY1) / fLength) * 180 / PI;
	DOUBLE az = acos((fZ2 - fZ1) / fLength) * 180 / PI;

	// 3. 存储数据
	EquipDataAngle *pAngle = new EquipDataAngle();
	pAngle->SetTaskId(m_iTaskId);
	pAngle->SetEquipCode(m_szEquipCode);
	pAngle->SetItemId(6); //
	pAngle->SetLineTitle(fcount);
	pAngle->SetLineCode(fcount);
	pAngle->SetLineStartX(fX1);
	pAngle->SetLineStartY(fY1);
	pAngle->SetLineStartZ(fZ1);
	pAngle->SetLineEndX(fX2);
	pAngle->SetLineEndY(fY2);
	pAngle->SetLineEndZ(fZ2);
	pAngle->SetAngleAX(ax);
	pAngle->SetAngleAY(ay);
	pAngle->SetAngleAZ(az);

	this->AddAngle(pAngle);

	return;
}
/**************************************************************************************************
函 数 名 :SaveToDB
功能描述 :批量存储到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::SaveToDB()
{
	// 计算Plane平面度
	this->CalcPointFlatness();

	// Calc Circle Roundness
	this->CalcCircleRoundness();

	// 生成偏角数据
	this->GenerateAngleText();
	this->GenerateDoublePoint();

	// 保存到数据库中
    int iRet = 0;
    iRet += SaveEquipDataToDB();
    iRet += SavePointToDB();
    iRet += SavePlaneToDB();
    iRet += SaveCircleToDB();
    iRet += SaveLineToDB();
    iRet += SaveCylinderToDB();
	iRet += SaveAngleToDB();
    iRet += SavePointRelatedToDB();

    if (iRet > 0) return FALSE;
    
    return TRUE;
}

/**************************************************************************************************
函 数 名 :Validate
功能描述 :数据完整性验证
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
BOOL StaticData::Validate(CString &szMsg) {
	CString rules =  AppConfig::GetString(_T("Data-Integrity"), this->m_szEquipTypeCode);
	CStringArray arrRules;
	Utils::StrSplit(rules, ",", arrRules);
	
	int icount = (int)arrRules.GetCount();
	EquipDataPoint *pPoint = NULL;
	BOOL bRet = TRUE;
   
	for (int i = 0; i < icount; i++) {
		pPoint = this->SearchPointByCode(arrRules[i]);
		if (pPoint == NULL) {
			if (bRet) {
				szMsg.Append(_T("关键点未测得："));
				bRet = FALSE;
			}
			szMsg.Append(arrRules[i]);
			szMsg.Append("/");
		}
	}

	if (!szMsg.IsEmpty())
	{
		szMsg.TrimRight('/');
	}
    
	return bRet;    
}

/**************************************************************************************************
函 数 名 :SaveEquipDataToDB
功能描述 :存储Equip数据类别到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SaveEquipDataToDB()
{
    POSITION   pos;
    EquipData *pData = NULL;
    CString szLine;
    EquipDataManager *pManager = new EquipDataManager();
    pManager->Delete(m_iTaskId);

	pos = m_DataList.GetHeadPosition();
	while (pos != NULL)
	{
		pData = (EquipData *)m_DataList.GetNext(pos);
		if (pData != NULL)
		{
		    pManager->Add(*pData);
		}
	}
    
    delete pManager;

    return 0;
}


/**************************************************************************************************
函 数 名 :SavePointToDB
功能描述 :存储Line到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SavePointToDB()
{
    POSITION   pos;
    EquipDataPoint *pPoint = NULL;
    EquipDataPointManager *pPointManager = new EquipDataPointManager();
    pPointManager->Delete(m_iTaskId);
    BOOL bRet = TRUE;

	pos = m_PointList.GetHeadPosition();
	while (pos != NULL)
	{
		pPoint = (EquipDataPoint *)m_PointList.GetNext(pos);
		if (pPoint != NULL)
		{
		   bRet = pPointManager->Add(*pPoint);
           if (bRet != TRUE)
           {
               AfxMessageBox("Point数据存储失败！"); 
               break;
           }
		}
	}

    delete pPointManager;

    return 0;
}


/**************************************************************************************************
函 数 名 :SavePlaneToDB
功能描述 :存储Plane到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SavePlaneToDB()
{
    POSITION   pos;
    EquipDataPlane *pPlane = NULL;
    EquipDataPlaneManager *pPlaneManager = new EquipDataPlaneManager();
    pPlaneManager->Delete(m_iTaskId);

    BOOL bRet = TRUE;

	pos = m_PlaneList.GetHeadPosition();
	while (pos != NULL)
	{
		pPlane = (EquipDataPlane *)m_PlaneList.GetNext(pos);
		if (pPlane != NULL)
		{
		   bRet = pPlaneManager->Add(*pPlane);
           if (bRet != TRUE)
           {
               AfxMessageBox("Plane数据存储失败！"); 
               break;
           }
		}
	}
    delete pPlaneManager;

    return 0;
}

/**************************************************************************************************
函 数 名 :SaveCircleToDB
功能描述 :存储Circle到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SaveCircleToDB()
{
	POSITION   pos;
    EquipDataCircle *pCircle = NULL;
    EquipDataCircleManager *pCircleManager = new EquipDataCircleManager();
    pCircleManager->Delete(m_iTaskId);

    BOOL bRet = TRUE;

	pos = m_CircleList.GetHeadPosition();
	while (pos != NULL)
	{
		pCircle = (EquipDataCircle *)m_CircleList.GetNext(pos);
		if (pCircle != NULL)
		{
		   bRet = pCircleManager->Add(*pCircle);
           if (bRet != TRUE)
           {
               AfxMessageBox("Circle数据存储失败！"); 
               break;
           }
		}
	}
    delete pCircleManager;
   
    return 0;
}

/**************************************************************************************************
函 数 名 :SaveLineToDB
功能描述 :存储Line到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SaveLineToDB()
{
    POSITION   pos;
    EquipDataLine *pLine = NULL;
    EquipDataLineManager *pLineManager = new EquipDataLineManager();
    pLineManager->Delete(m_iTaskId);

    BOOL bRet = TRUE;

	pos = m_LineList.GetHeadPosition();
	while (pos != NULL)
	{
		pLine = (EquipDataLine *)m_LineList.GetNext(pos);
		if (pLine != NULL)
		{
		   bRet = pLineManager->Add(*pLine);
           if (bRet != TRUE)
           {
               AfxMessageBox("Line数据存储失败！"); 
               break;
           }
		}
	}

    delete pLineManager;

    return 0;
}

/**************************************************************************************************
函 数 名 :SavePointToDB
功能描述 :存储Line到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SaveCylinderToDB()
{
    POSITION   pos;
    EquipDataCylinder *pCylinder = NULL;
    EquipDataCylinderManager *pCylinderManager = new EquipDataCylinderManager();
    pCylinderManager->Delete(m_iTaskId);

    BOOL bRet = TRUE;

	pos = m_CylinderList.GetHeadPosition();
	while (pos != NULL)
	{
		pCylinder = (EquipDataCylinder *)m_CylinderList.GetNext(pos);
		if (pCylinder != NULL)
		{
		   bRet = pCylinderManager->Add(*pCylinder);
           if (bRet != TRUE)
           {
               AfxMessageBox("Line数据存储失败！"); 
               break;
           }
		}
	}

    delete pCylinderManager;

    return 0;
}


/**************************************************************************************************
函 数 名 :SaveAngleToDB
功能描述 :存储Angle到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SaveAngleToDB()
{
	POSITION   pos;
	EquipDataAngle *pAngle = NULL;
	EquipDataAngleManager *pAngleManager = new EquipDataAngleManager();
	pAngleManager->Delete(m_iTaskId);

	BOOL bRet = TRUE;

	pos = m_AngleList.GetHeadPosition();
	while (pos != NULL)
	{
		pAngle = (EquipDataAngle *)m_AngleList.GetNext(pos);
		if (pAngle != NULL)
		{
			bRet = pAngleManager->Add(*pAngle);
			if (bRet != TRUE)
			{
				AfxMessageBox("Angle数据存储失败！");
				break;
			}
		}
	}

	delete pAngleManager;

	return 0;
}


/**************************************************************************************************
函 数 名 :SavePointToDB
功能描述 :存储Line到数据库
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::SavePointRelatedToDB()
{
    POSITION   pos;
    EquipDataPointRelated *pPointRelated = NULL;
    EquipDataPointRelatedManager *pPointRelatedManager = new EquipDataPointRelatedManager();
    pPointRelatedManager->Delete(m_iTaskId);

    BOOL bRet = TRUE;

	pos = m_PointRelatedList.GetHeadPosition();
	while (pos != NULL)
	{
		pPointRelated = (EquipDataPointRelated *)m_PointRelatedList.GetNext(pos);
		if (pPointRelated != NULL)
		{
		   bRet = pPointRelatedManager->Add(*pPointRelated);
           if (bRet != TRUE)
           {
               AfxMessageBox("Line数据存储失败！"); 
               break;
           }
		}
	}

    delete pPointRelatedManager;

    return 0;
}

/**************************************************************************************************
函 数 名 :OutputConfig
功能描述 :输出配置文件
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::OutputConfig()
{
	CString szFile1   = AppConfig::GetString("Output", "File1");
	CString szPoints1 = AppConfig::GetString("Output", "File1_Points");
	if (!szFile1.IsEmpty()) {
		this->OutputDataToFile(szFile1, szPoints1);
	}
    
	CString szFile2   = AppConfig::GetString("Output", "File2");
	CString szPoints2 = AppConfig::GetString("Output", "File2_Points");
	if (!szFile2.IsEmpty()) {
		this->OutputDataToFile(szFile2, szPoints2);
	}

	CString szFile3   = AppConfig::GetString("Output", "File3");
	CString szPoints3 = AppConfig::GetString("Output", "File3_Points");
	if (!szFile3.IsEmpty()) {
		this->OutputDataToFile(szFile3, szPoints3);
	}

	CString szFile4   = AppConfig::GetString("Output", "File4");
	CString szPoints4 = AppConfig::GetString("Output", "File4_Points");
	if (!szFile4.IsEmpty()) {
		this->OutputDataToFile(szFile4, szPoints4);
	}

	CString szFile5   = AppConfig::GetString("Output", "File5");
	CString szPoints5 = AppConfig::GetString("Output", "File5_Points");
	if (!szFile5.IsEmpty()) {
		this->OutputDataToFile(szFile5, szPoints5);
	}

    return 0;
}

/**************************************************************************************************
函 数 名 :OutputDataToFile
功能描述 :输出点数据到文件
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
int StaticData::OutputDataToFile(const CString &szFile, const CString &strPoints)
{
	CStdioFile file;

	if (!file.Open(szFile, CFile::typeText | CFile::modeCreate | CFile::modeReadWrite))
	{
		LOG::E(_T("文件失败"));
		return 1;
	}

	CStringArray szArray;
	Utils::StrSplit(strPoints, ",", szArray);

	POSITION   pos;
	EquipDataPoint *pPoint = NULL;
	CString szLine;
	

	pos = m_PointList.GetHeadPosition();
	while (pos != NULL)
	{
		pPoint = (EquipDataPoint *)m_PointList.GetNext(pos);
		if (pPoint != NULL)
		{
			CString szPoint = pPoint->GetPointCode();
			for (int i = 0; i < szArray.GetSize(); i++)
			{
				CString szPointTarget = szArray.GetAt(i);
				if (!szPointTarget.IsEmpty())
				{
					if (szPointTarget.CompareNoCase(szPoint)==0)
					{
						szLine.Format("%20s  %.3f  %.3f  %.3f\n"
							, pPoint->GetPointTitle()
							, pPoint->GetPointAX()
							, pPoint->GetPointAY()
							, pPoint->GetPointAZ());
						file.WriteString(szLine);
					}
				}

			}
			
		}
	}

	file.Close();

	return 0;
}



/**************************************************************************************************
函 数 名 :PrintData
功能描述 :调试打印
输入参数 :无
输出参数 :无
返 回 值 :void
**************************************************************************************************/
void StaticData::PrintData()
{
    CStdioFile file;
    CString szFile("D:\\data.txt");
    if (!file.Open(szFile, CFile::typeText|CFile::modeCreate|CFile::modeReadWrite))
    {
       LOG::E(_T("打开文件失败"));
       return ;
    }
    
    this->PrintEquipData(&file);
    this->PrintPoint(&file);
    this->PrintPlane(&file);
    this->PrintCircle(&file);
    this->PrintLine(&file);
    this->PrintCylinder(&file);
	this->PrintAngle(&file);
    this->PrintPointRelated(&file);

    file.Close();
}

// 打印输出Equip Data
void StaticData::PrintEquipData(CStdioFile *pFile)
{
    POSITION   pos;
    EquipData *pData = NULL;

    CString szLine;
    szLine.Format("-------------------------------------------------------------------------------\n");
    pFile->WriteString(szLine);
    szLine.Format(" equipCode        itemId          itemCode         itemTitle           itemType\n");
    pFile->WriteString(szLine);

	pos = m_DataList.GetHeadPosition();
	while (pos != NULL)
	{
		pData = (EquipData *)m_DataList.GetNext(pos);
		if (pData != NULL)
		{
		    szLine.Format(" %20s          %d          %s          %s           %d\n" 
                          ,pData->GetEquipCode()
                          ,pData->GetItemId()
                          ,pData->GetItemCode()
                          ,pData->GetItemTitle()
                          ,pData->GetItemType());
            pFile->WriteString(szLine);
		}
	}
}

// 打印输出点数据
void StaticData::PrintPoint(CStdioFile *pFile)
{
    POSITION   pos;
    EquipDataPoint *pPoint = NULL;
    CString szLine;

    szLine.Format("------------------------------------------------------------------------------------\n");
    pFile->WriteString(szLine);
    szLine.Format("equipCode    itemId    subitemId   pointTitle       pointAX     pointAY     pointAZ   pointTotal\n");
    pFile->WriteString(szLine);

	pos = m_PointList.GetHeadPosition();
	while (pos != NULL)
	{
		pPoint = (EquipDataPoint *)m_PointList.GetNext(pos);
		if (pPoint != NULL)
		{
		    szLine.Format(" %20s          %d           %d           %s          %.3f           %.3f          %.3f       %.3f\n" 
                          ,pPoint->GetEquipCode()
                          ,pPoint->GetItemId()
                          ,pPoint->GetSubItemId()
                          ,pPoint->GetPointTitle()
                          ,pPoint->GetPointAX()
                          ,pPoint->GetPointAY()
                          ,pPoint->GetPointAZ()
			              ,pPoint->GetPointTotal());
            pFile->WriteString(szLine);
		}
	}
}

// 打印输出平面数据
void StaticData::PrintPlane(CStdioFile *pFile)
{
    POSITION   pos;
    EquipDataPlane *pPlane = NULL;
    CString szLine;

    szLine.Format("------------------------------------------------------------------------------------\r\n");
    pFile->WriteString(szLine);
    szLine.Format("%20s    %20s    %20s    %20s    %20s \r\n", "equipCode", "itemId",  "subitemId" , "planeCode", "A", "B", "C", "D", "RMS");
    pFile->WriteString(szLine);

	pos = m_PlaneList.GetHeadPosition();
	while (pos != NULL)
	{
		pPlane = (EquipDataPlane *)m_PlaneList.GetNext(pos);
		if (pPlane != NULL)
		{
		    szLine.Format("%20s    %20d    %20d    %20s    %20.3f    %20.3f    %20.3f    %20.3f    %20.3f    %20.3f\r\n" 
                          ,pPlane->GetEquipCode()
                          ,pPlane->GetItemId()
                          ,pPlane->GetSubItemId()
                          ,pPlane->GetPlaneCode()
                          ,pPlane->GetPlaneA()
                          ,pPlane->GetPlaneB()
                          ,pPlane->GetPlaneC()
                          ,pPlane->GetPlaneD()
                          ,pPlane->GetPlaneRMS()
			              ,pPlane->GetPlaneFlatness());
            pFile->WriteString(szLine);
		}
	}
}

// 打印输出圆数据
void StaticData::PrintCircle(CStdioFile *pFile)
{
    POSITION   pos;
    EquipDataCircle *pCircle = NULL;
    CString szLine;

    szLine.Format("------------------------------------------------------------------------------------\r\n");
    pFile->WriteString(szLine);
    szLine.Format("equipCode    itemId    subitemId   CircelCode    C-X       C-Y       C-Z       Raidus      RMS \r\n");
    pFile->WriteString(szLine);

	pos = m_CircleList.GetHeadPosition();
	while (pos != NULL)
	{
		pCircle = (EquipDataCircle *)m_CircleList.GetNext(pos);
		if (pCircle != NULL)
		{
		    szLine.Format("%20s      %d        %d      %s       (%.3f        %.3f        %.3f)        %.3f        %.3f \r\n" 
                          ,pCircle->GetEquipCode()
                          ,pCircle->GetItemId()
                          ,pCircle->GetSubItemId()
                          ,pCircle->GetCircleCode()
                          ,pCircle->GetCircleCenterX()
                          ,pCircle->GetCircleCenterY()
                          ,pCircle->GetCircleCenterZ()
                          ,pCircle->GetCircleRadius()
                          ,pCircle->GetCircleRMS());
            pFile->WriteString(szLine);
		}
	}
}

// 打印输出直线数据
void StaticData::PrintLine(CStdioFile *pFile)
{
    POSITION   pos;
    EquipDataLine *pLine = NULL;
    CString szLine;

    szLine.Format("---------------------------------------------------------------------------------------------------------------------------------------------------\r\n");
    pFile->WriteString(szLine);
    szLine.Format("equipCode    itemId    subitemId   lineCode    Vec-X       Vec-Y       Vec-Z       Start-X    Start-Y   Start-Z   End-X   End-Y    End-Z    Length \r\n");
    pFile->WriteString(szLine);


	pos = m_LineList.GetHeadPosition();
	while (pos != NULL)
	{
		pLine = (EquipDataLine *)m_LineList.GetNext(pos);
		if (pLine != NULL)
		{
		    szLine.Format("%20s      %d        %d      %s   (%.3f        %.3f        %.3f)(%.3f        %.3f        %.3f) (%.3f        %.3f        %.3f)    %.3f  \r\n" 
                          ,pLine->GetEquipCode()
                          ,pLine->GetItemId()
                          ,pLine->GetSubItemId()
                          ,pLine->GetLineCode()
                          ,pLine->GetLineVectorX()
                          ,pLine->GetLineVectorY()
                          ,pLine->GetLineVectorZ()
                          ,pLine->GetLineStartX()
                          ,pLine->GetLineStartY()
                          ,pLine->GetLineStartZ()
                          ,pLine->GetLineEndX()
                          ,pLine->GetLineEndY()
                          ,pLine->GetLineEndZ()
                          ,pLine->GetLineLength());
            pFile->WriteString(szLine);
		}
	}
}

// 打印输出圆柱数据
void StaticData::PrintCylinder(CStdioFile *pFile)
{
    POSITION   pos;
    EquipDataCylinder *pCylinder = NULL;
    CString szLine;
    szLine.Format("------------------------------------------------------------------------------------------------------------------------------------------\r\n");
    pFile->WriteString(szLine);
    szLine.Format("equipCode    itemId    subitemId   CylinderCode    P1-X       P1-Y       P1-Z         P2-X        P2-Y      P2-Z       Radius     Length \r\n");
    pFile->WriteString(szLine);


	pos = m_CylinderList.GetHeadPosition();
	while (pos != NULL)
	{
		pCylinder = (EquipDataCylinder *)m_CylinderList.GetNext(pos);
		if (pCylinder != NULL)
		{
		    szLine.Format("%20s      %d        %d      %s       (%.3f        %.3f        %.3f)    (%.3f        %.3f        %.3f)     %.3f        %.3f \r\n" 
                          ,pCylinder->GetEquipCode()
                          ,pCylinder->GetItemId()
                          ,pCylinder->GetSubItemId()
                          ,pCylinder->GetCylinderCode()
                          ,pCylinder->GetPoint1X()
                          ,pCylinder->GetPoint1Y()
                          ,pCylinder->GetPoint1Z()
                          ,pCylinder->GetPoint2X()
                          ,pCylinder->GetPoint2Y()
                          ,pCylinder->GetPoint2Z()
                          ,pCylinder->GetCylinderRadius()
                          ,pCylinder->GetCylinderLength());
            pFile->WriteString(szLine);
		}
	}
}

// 打印输出圆柱数据
void StaticData::PrintAngle(CStdioFile *pFile)
{
	POSITION   pos;
	EquipDataAngle *pAngle = NULL;
	CString szLine;
	szLine.Format("------------------------------------------------------------------------------------------------------------------------------------------\r\n");
	pFile->WriteString(szLine);
	szLine.Format("equipCode    itemId    subitemId   CylinderCode    P1-X       P1-Y       P1-Z         P2-X        P2-Y      P2-Z       Radius     Length \r\n");
	pFile->WriteString(szLine);


	pos = m_AngleList.GetHeadPosition();
	while (pos != NULL)
	{
		pAngle = (EquipDataAngle *)m_AngleList.GetNext(pos);
		if (pAngle != NULL)
		{
			szLine.Format("%20s      %d        %d        %s       %s     (%.3f        %.3f        %.3f)    (%.3f        %.3f        %.3f) \r\n"
				, pAngle->GetEquipCode()
				, pAngle->GetItemId()
				, pAngle->GetSubItemId()
				, pAngle->GetLineCode()
				, pAngle->GetLineTitle()
				, pAngle->GetAngleAX()
				, pAngle->GetAngleAY()
				, pAngle->GetAngleAZ()
				, pAngle->GetAngleEX()
				, pAngle->GetAngleEY()
				, pAngle->GetAngleEZ());
			pFile->WriteString(szLine);
		}
	}
}


// 打印点残差数据
void StaticData::PrintPointRelated(CStdioFile *pFile)
{
    POSITION   pos;
    EquipDataPointRelated *pPointRelated = NULL;
    CString szLine;
    szLine.Format("---------------------------------------------------------------------------\r\n");
    pFile->WriteString(szLine);
    szLine.Format("equipCode       itemId       subitemId   itemType   PointSubItemId \r\n");
    pFile->WriteString(szLine);

	pos = m_PointRelatedList.GetHeadPosition();
	while (pos != NULL)
	{
		pPointRelated = (EquipDataPointRelated *)m_PointRelatedList.GetNext(pos);
		if (pPointRelated != NULL)
		{
		    szLine.Format("%20s         %d          %d          %d          %d\n" 
                          ,pPointRelated->GetEquipCode()
                          ,pPointRelated->GetItemId()
                          ,pPointRelated->GetSubItemId()
                          ,pPointRelated->GetItemType()
                          ,pPointRelated->GetPointSubItemId());
            pFile->WriteString(szLine);
		}
	}
}