/********************************************************************
	created:	2007/10/15
	created:	15:10:2007   10:04
	filename: 	f:\tg_dev\水电开发\tch_public\twtfun.cpp
	file path:	f:\tg_dev\水电开发\tch_public
	file base:	twtfun
	file ext:	cpp
	author:		沈睿
	
	purpose:	给排水公共函数，导出
*********************************************************************/

#include "stdafx.h"

#include "TAPI.h"
#include "twtdef.h"
#include "xblock.h"

//#include <arxtools.h>
#include <rxregsvc.h>
#include <dbwell.h>
//#include <dbwall.h>
#include <DbDoubleLinePipe.h>
#include <dbPipeValve.h>
#include <DbPipeLabel.h>
#include <DbVPipeDim.h>
#include "SSearchPipeList.h"
#include "DbPump.h"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           文字部分
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

extern int CALLBACK EnumFontFamExProc2(ENUMLOGFONTEX *lplf, NEWTEXTMETRICEX *lpntme, int FontType, LONG lParam);
extern int CALLBACK EnumFontFamExProc3(ENUMLOGFONTEX *lplf, NEWTEXTMETRICEX *lpntme, int FontType, LONG lParam);
int CALLBACK EnumFontFamExProc33(ENUMLOGFONTEX *lplf, NEWTEXTMETRICEX *lpntme,
                                int FontType, LONG lParam)
{
    if (!(FontType & TRUETYPE_FONTTYPE))
        return 1 ;
    if (*(lplf->elfLogFont.lfFaceName))
    {
        if(!_tcsicmp(lplf->elfLogFont.lfFaceName, _T("marlett")))
            return 1;
        
        if(g_lstWinfont.Index(lplf->elfLogFont.lfFaceName, 0) < 0 &&
            _tcsicmp((const TCHAR*)lplf->elfScript, _T("CHINESE_GB2312")) == 0)	{// winFont
            g_lstWinfont.Append(tstrnew(lplf->elfLogFont.lfFaceName));
            g_lstCharset.Append(new int(lplf->elfLogFont.lfCharSet));
            g_lstPitch.Append(new int(lplf->elfLogFont.lfPitchAndFamily));
        }
    }
    return 1 ;
}

//初始化给排水文字样式
AcDbObjectId InitTwtTextStyle(const TCHAR *szTextStyle)
{
    AcDbObjectId idRet;
    idRet=GetTextStyleId(szTextStyle);
    if(!idRet) {

        g_lstWinfont.Reset();
        g_lstCharset.Reset();
        g_lstPitch.Reset();
        CDC *pDC = acedGetAcadDwgView()->GetDC();
        ASSERT(pDC);	
        LOGFONT lf;
        ZeroMemory(&lf,sizeof(lf));
        lf.lfCharSet = DEFAULT_CHARSET;
        EnumFontFamiliesEx(pDC->m_hDC, &lf,          
            (FONTENUMPROC)EnumFontFamExProc33, NULL, 0);
        acedGetAcadDwgView()->ReleaseDC(pDC);
        
        AcDbTextStyleTableRecord *pStyle=new AcDbTextStyleTableRecord;
        pStyle->setName(szTextStyle);
        if(_tcsicmp(szTextStyle, g_csPipeDnStyle) == 0){    //管径标注
            pStyle->setTextSize(g_nPipeDnHeight);
            pStyle->setXScale(g_nPipeDnScale);
            int idx = g_lstWinfont.Index(g_csPipeDnChn);
            if(idx < 0){
                pStyle->setFileName(g_csPipeDnEng);
                pStyle->setBigFontFileName(g_csPipeDnChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csPipeDnChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csPipeDnChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
        else if(_tcsicmp(szTextStyle, g_csVPipeStyle) == 0){//立管标注
            pStyle->setTextSize(g_nVPipeHeight);
            pStyle->setXScale(g_nVPipeScale);
            int idx = g_lstWinfont.Index(g_csVPipeChn);
            if(idx < 0){
                pStyle->setFileName(g_csVPipeEng);
                pStyle->setBigFontFileName(g_csVPipeChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csVPipeChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csVPipeChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
        else if(_tcsicmp(szTextStyle, g_csPipeTextStyle) == 0){//管线文字
            pStyle->setTextSize(g_nPipeTextHeight);
            pStyle->setXScale(g_nPipeTextScale);
            int idx = g_lstWinfont.Index(g_csPipeTextChn);
            if(idx < 0){
                pStyle->setFileName(g_csPipeTextEng);
                pStyle->setBigFontFileName(g_csPipeTextChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csPipeTextChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csPipeTextChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
        else if(_tcsicmp(szTextStyle, g_csCircleTextStyle) == 0){//圆中文字
            pStyle->setTextSize(g_nCircleTextHeight);
            pStyle->setXScale(g_nCircleTextScale);
            int idx = g_lstWinfont.Index(g_csCircleTextChn);
            if(idx < 0){
                pStyle->setFileName(g_csCircleTextEng);
                pStyle->setBigFontFileName(g_csCircleTextChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csCircleTextChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csCircleTextChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
        else if(_tcsicmp(szTextStyle, g_csSanTextStyle) == 0){//洁具标注 sr add 2010-12-16
            pStyle->setTextSize(g_nSanTextHeight);
            pStyle->setXScale(g_nSanTextScale);
            int idx = g_lstWinfont.Index(g_csSanTextChn);
            if(idx < 0){
                pStyle->setFileName(g_csSanTextEng);
                pStyle->setBigFontFileName(g_csSanTextChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csSanTextChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csSanTextChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
        else if(_tcsicmp(szTextStyle, g_csDimWellStyle) == 0){  //井标注
            pStyle->setTextSize(g_nDimWellHeight);
            pStyle->setXScale(g_nDimWellScale);
            int idx = g_lstWinfont.Index(g_csDimWellChn);
            if(idx < 0){
                pStyle->setFileName(g_csDimWellEng);
                pStyle->setBigFontFileName(g_csDimWellChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csDimWellChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csDimWellChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
        else if(_tcsicmp(szTextStyle, g_csSheetStyle) == 0){  //表格文字
            pStyle->setTextSize(g_nSheetHeight);
            pStyle->setXScale(g_nSheetScale);
            int idx = g_lstWinfont.Index(g_csSheetChn);
            if(idx < 0){
                pStyle->setFileName(g_csSheetEng);
                pStyle->setBigFontFileName(g_csSheetChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csSheetChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csSheetChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
        else if(_tcsicmp(szTextStyle, g_csTwtDimStyle) == 0){  //标注文字
            pStyle->setTextSize(g_nTwtDimHeight);
            pStyle->setXScale(g_nDimScale);
            int idx = g_lstWinfont.Index(g_csDimChn);
            if(idx < 0){
                pStyle->setFileName(g_csDimEng);
                pStyle->setBigFontFileName(g_csDimChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csDimChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csDimChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }
		else if(_tcsicmp(szTextStyle, g_csEleDimStyle) == 0){  //标高文字 cet 2012.7.3 add
            pStyle->setTextSize(g_nEleDimHeight);
            pStyle->setXScale(g_nEleDimScale);
            int idx = g_lstWinfont.Index(g_csEleDimChn);
            if(idx < 0){
                pStyle->setFileName(g_csEleDimEng);
                pStyle->setBigFontFileName(g_csEleDimChn);
            }
            else{
                int iCharset = *g_lstCharset[idx];
                int iPitch = *g_lstPitch[idx];
#if ADS > 20
				pStyle->setFont(g_csEleDimChn, false, false, (Charset)iCharset, (Autodesk::AutoCAD::PAL::FontUtils::FontPitch)iPitch, Autodesk::AutoCAD::PAL::FontUtils::FontFamily::kDoNotCare);
#else
				pStyle->setFont(g_csEleDimChn, FALSE, FALSE, iCharset, iPitch);
#endif
				// modify by cq 2017-01-05 支持CAD2017
            }
        }

        // 扩展数据
        resbuf *pXData = ads_buildlist(1001, TCHXD, 1040, 1.0, 1040, 0.8, 1070, 0, NULL);
        if(!XSymbolTable(_T("APPID"), TCHXD))
            ads_regapp(TCHXD);
        pStyle->setXData(pXData);
        ads_relrb(pXData);
        idRet=AddTextStyle(pStyle, TRUE);
    }
    xg_setvar(_T("TEXTSTYLE"), szTextStyle);
    
    return idRet;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           管线标注
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void UpdateMultDim()
{
	RBList rbMaskDim(RTDXF0, _T("ATS_PIPEMULTDIM"), NULL);
	PickSet ssDim(SS_FREE);
	ssDim.Get(_T("X"), NULL, NULL, rbMaskDim);
	long len = ssDim.Length();
	if(len > 0)
		UpdateGraphic(ssDim);
}
//以下数据采用《钢制管件》02S403 P75
void GetFlangeDataByDn(int m_iPn, double m_dRetDn, double &m_nFlangeDn, double &m_nFlangeThick) 
{
    
	if(m_iPn == 0){ //0.25MPa
		if(fabs(m_dRetDn - 50) < 0.01){ 
			m_nFlangeDn = 140;
			m_nFlangeThick = 12;
		}
		else if(fabs(m_dRetDn - 65) < 0.01){
			m_nFlangeDn = 160;
			m_nFlangeThick = 14;
		}
		else if(fabs(m_dRetDn - 80) < 0.01){
			m_nFlangeDn = 190;
			m_nFlangeThick = 14;
		}
		else if(fabs(m_dRetDn - 100) < 0.01){
			m_nFlangeDn = 210;
			m_nFlangeThick = 14;
		}
		else if(fabs(m_dRetDn - 125) < 0.01){
			m_nFlangeDn = 240;
			m_nFlangeThick = 14;
		}
		else if(fabs(m_dRetDn - 150) < 0.01){
			m_nFlangeDn = 265;
			m_nFlangeThick = 16;
		}
		else if(fabs(m_dRetDn - 200) < 0.01){
			m_nFlangeDn = 320;
			m_nFlangeThick = 18;
		}
		else if(fabs(m_dRetDn - 250) < 0.01){
			m_nFlangeDn = 375;
			m_nFlangeThick = 22;
		}
		else if(fabs(m_dRetDn - 300) < 0.01){
			m_nFlangeDn = 440;
			m_nFlangeThick = 22;
		}
		else if(fabs(m_dRetDn - 350) < 0.01){
			m_nFlangeDn = 490;
			m_nFlangeThick = 22;
		}
		else if(fabs(m_dRetDn - 400) < 0.01){
			m_nFlangeDn = 540;
			m_nFlangeThick = 22;
		}
		else if(fabs(m_dRetDn - 450) < 0.01){
			m_nFlangeDn = 595;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 500) < 0.01){
			m_nFlangeDn = 645;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 600) < 0.01){
			m_nFlangeDn = 755;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 700) < 0.01){
			m_nFlangeDn = 860;
			m_nFlangeThick = 26;
		}
		else if(fabs(m_dRetDn - 800) < 0.01){
			m_nFlangeDn = 975;
			m_nFlangeThick = 26;
		}
		else if(fabs(m_dRetDn - 900) < 0.01){
			m_nFlangeDn = 1075;
			m_nFlangeThick = 28;
		}
		else if(fabs(m_dRetDn - 1000) < 0.01){
			m_nFlangeDn = 1175;
			m_nFlangeThick = 30;
		}
		else if(fabs(m_dRetDn - 1200) < 0.01){
			m_nFlangeDn = 1375;
			m_nFlangeThick = 30;
		}
		else if(fabs(m_dRetDn - 1400) < 0.01){
			m_nFlangeDn = 1575;
			m_nFlangeThick = 32;
		}
		else if(fabs(m_dRetDn - 1600) < 0.01){
			m_nFlangeDn = 1790;
			m_nFlangeThick = 32;
		}
		else if(fabs(m_dRetDn - 1800) < 0.01){
			m_nFlangeDn = 1990;
			m_nFlangeThick = 34;
		}
		else if(fabs(m_dRetDn - 2000) < 0.01){
			m_nFlangeDn = 2190;
			m_nFlangeThick = 34;
		}
	}
	else if(m_iPn == 1){//0.6MPa
		if(fabs(m_dRetDn - 50) < 0.01){ 
			m_nFlangeDn = 140;
			m_nFlangeThick = 16;
		}
		else if(fabs(m_dRetDn - 65) < 0.01){
			m_nFlangeDn = 160;
			m_nFlangeThick = 16;
		}
		else if(fabs(m_dRetDn - 80) < 0.01){
			m_nFlangeDn = 190;
			m_nFlangeThick = 18;
		}
		else if(fabs(m_dRetDn - 100) < 0.01){
			m_nFlangeDn = 210;
			m_nFlangeThick = 18;
		}
		else if(fabs(m_dRetDn - 125) < 0.01){
			m_nFlangeDn = 240;
			m_nFlangeThick = 20;
		}
		else if(fabs(m_dRetDn - 150) < 0.01){
			m_nFlangeDn = 265;
			m_nFlangeThick = 20;
		}
		else if(fabs(m_dRetDn - 200) < 0.01){
			m_nFlangeDn = 320;
			m_nFlangeThick = 22;
		}
		else if(fabs(m_dRetDn - 250) < 0.01){
			m_nFlangeDn = 375;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 300) < 0.01){
			m_nFlangeDn = 440;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 350) < 0.01){
			m_nFlangeDn = 490;
			m_nFlangeThick = 26;
		}
		else if(fabs(m_dRetDn - 400) < 0.01){
			m_nFlangeDn = 540;
			m_nFlangeThick = 28;
		}
		else if(fabs(m_dRetDn - 450) < 0.01){
			m_nFlangeDn = 595;
			m_nFlangeThick = 28;
		}
		else if(fabs(m_dRetDn - 500) < 0.01){
			m_nFlangeDn = 645;
			m_nFlangeThick = 30;
		}
		else if(fabs(m_dRetDn - 600) < 0.01){
			m_nFlangeDn = 755;
			m_nFlangeThick = 30;
		}
		else if(fabs(m_dRetDn - 700) < 0.01){
			m_nFlangeDn = 860;
			m_nFlangeThick = 32;
		}
		else if(fabs(m_dRetDn - 800) < 0.01){
			m_nFlangeDn = 975;
			m_nFlangeThick = 32;
		}
		else if(fabs(m_dRetDn - 900) < 0.01){
			m_nFlangeDn = 1075;
			m_nFlangeThick = 34;
		}
		else if(fabs(m_dRetDn - 1000) < 0.01){
			m_nFlangeDn = 1175;
			m_nFlangeThick = 36;
		}
		else if(fabs(m_dRetDn - 1200) < 0.01){
			m_nFlangeDn = 1405;
			m_nFlangeThick = 38;
		}
		else if(fabs(m_dRetDn - 1400) < 0.01){
			m_nFlangeDn = 1630;
			m_nFlangeThick = 44;
		}
		else if(fabs(m_dRetDn - 1600) < 0.01){
			m_nFlangeDn = 1830;
			m_nFlangeThick = 46;
		}
		else if(fabs(m_dRetDn - 1800) < 0.01){
			m_nFlangeDn = 2045;
			m_nFlangeThick = 52;
		}
		else if(fabs(m_dRetDn - 2000) < 0.01){
			m_nFlangeDn = 2265;
			m_nFlangeThick = 54;
		}
	}
	else if(m_iPn == 2){//1.0MPa
		if(fabs(m_dRetDn - 50) < 0.01){ 
			m_nFlangeDn = 165;
			m_nFlangeThick = 18;
		}
		else if(fabs(m_dRetDn - 65) < 0.01){
			m_nFlangeDn = 185;
			m_nFlangeThick = 20;
		}
		else if(fabs(m_dRetDn - 80) < 0.01){
			m_nFlangeDn = 200;
			m_nFlangeThick = 20;
		}
		else if(fabs(m_dRetDn - 100) < 0.01){
			m_nFlangeDn = 220;
			m_nFlangeThick = 22;
		}
		else if(fabs(m_dRetDn - 125) < 0.01){
			m_nFlangeDn = 250;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 150) < 0.01){
			m_nFlangeDn = 285;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 200) < 0.01){
			m_nFlangeDn = 340;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 250) < 0.01){
			m_nFlangeDn = 395;
			m_nFlangeThick = 26;
		}
		else if(fabs(m_dRetDn - 300) < 0.01){
			m_nFlangeDn = 445;
			m_nFlangeThick = 28;
		}
		else if(fabs(m_dRetDn - 350) < 0.01){
			m_nFlangeDn = 505;
			m_nFlangeThick = 28;
		}
		else if(fabs(m_dRetDn - 400) < 0.01){
			m_nFlangeDn = 565;
			m_nFlangeThick = 30;
		}
		else if(fabs(m_dRetDn - 450) < 0.01){
			m_nFlangeDn = 615;
			m_nFlangeThick = 30;
		}
		else if(fabs(m_dRetDn - 500) < 0.01){
			m_nFlangeDn = 670;
			m_nFlangeThick = 32;
		}
		else if(fabs(m_dRetDn - 600) < 0.01){
			m_nFlangeDn = 780;
			m_nFlangeThick = 36;
		}
		else if(fabs(m_dRetDn - 700) < 0.01){
			m_nFlangeDn = 895;
			m_nFlangeThick = 36;
		}
		else if(fabs(m_dRetDn - 800) < 0.01){
			m_nFlangeDn = 1015;
			m_nFlangeThick = 38;
		}
		else if(fabs(m_dRetDn - 900) < 0.01){
			m_nFlangeDn = 1115;
			m_nFlangeThick = 42;
		}
		else if(fabs(m_dRetDn - 1000) < 0.01){
			m_nFlangeDn = 1230;
			m_nFlangeThick = 44;
		}
		else if(fabs(m_dRetDn - 1200) < 0.01){
			m_nFlangeDn = 1455;
			m_nFlangeThick = 48;
		}
		else if(fabs(m_dRetDn - 1400) < 0.01){
			m_nFlangeDn = 1675;
			m_nFlangeThick = 54;
		}
		else if(fabs(m_dRetDn - 1600) < 0.01){
			m_nFlangeDn = 1915;
			m_nFlangeThick = 62;
		}
		else if(fabs(m_dRetDn - 1800) < 0.01){
			m_nFlangeDn = 2115;
			m_nFlangeThick = 66;
		}
		else if(fabs(m_dRetDn - 2000) < 0.01){
			m_nFlangeDn = 2325;
			m_nFlangeThick = 72;
		}
	}
	else if(m_iPn == 3){//1.6MPa
		if(fabs(m_dRetDn - 50) < 0.01){ 
			m_nFlangeDn = 165;
			m_nFlangeThick = 22;
		}
		else if(fabs(m_dRetDn - 65) < 0.01){
			m_nFlangeDn = 185;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 80) < 0.01){
			m_nFlangeDn = 200;
			m_nFlangeThick = 24;
		}
		else if(fabs(m_dRetDn - 100) < 0.01){
			m_nFlangeDn = 220;
			m_nFlangeThick = 26;
		}
		else if(fabs(m_dRetDn - 125) < 0.01){
			m_nFlangeDn = 250;
			m_nFlangeThick = 28;
		}
		else if(fabs(m_dRetDn - 150) < 0.01){
			m_nFlangeDn = 285;
			m_nFlangeThick = 28;
		}
		else if(fabs(m_dRetDn - 200) < 0.01){
			m_nFlangeDn = 340;
			m_nFlangeThick = 30;
		}
		else if(fabs(m_dRetDn - 250) < 0.01){
			m_nFlangeDn = 405;
			m_nFlangeThick = 32;
		}
		else if(fabs(m_dRetDn - 300) < 0.01){
			m_nFlangeDn = 460;
			m_nFlangeThick = 32;
		}
		else if(fabs(m_dRetDn - 350) < 0.01){
			m_nFlangeDn = 520;
			m_nFlangeThick = 34;
		}
		else if(fabs(m_dRetDn - 400) < 0.01){
			m_nFlangeDn = 580;
			m_nFlangeThick = 38;
		}
		else if(fabs(m_dRetDn - 450) < 0.01){
			m_nFlangeDn = 640;
			m_nFlangeThick = 42;
		}
		else if(fabs(m_dRetDn - 500) < 0.01){
			m_nFlangeDn = 715;
			m_nFlangeThick = 48;
		}
		else if(fabs(m_dRetDn - 600) < 0.01){
			m_nFlangeDn = 840;
			m_nFlangeThick = 50;
		}
		////////////////// pn 1。6MPA 没有以下管径，数据按1.0
		else if(fabs(m_dRetDn - 700) < 0.01){
			m_nFlangeDn = 895;
			m_nFlangeThick = 36;
		}
		else if(fabs(m_dRetDn - 800) < 0.01){
			m_nFlangeDn = 1015;
			m_nFlangeThick = 38;
		}
		else if(fabs(m_dRetDn - 900) < 0.01){
			m_nFlangeDn = 1115;
			m_nFlangeThick = 42;
		}
		else if(fabs(m_dRetDn - 1000) < 0.01){
			m_nFlangeDn = 1230;
			m_nFlangeThick = 44;
		}
		else if(fabs(m_dRetDn - 1200) < 0.01){
			m_nFlangeDn = 1450;
			m_nFlangeThick = 48;
		}
		else if(fabs(m_dRetDn - 1400) < 0.01){
			m_nFlangeDn = 1675;
			m_nFlangeThick = 54;
		}
		else if(fabs(m_dRetDn - 1600) < 0.01){
			m_nFlangeDn = 1915;
			m_nFlangeThick = 62;
		}
		else if(fabs(m_dRetDn - 1800) < 0.01){
			m_nFlangeDn = 2115;
			m_nFlangeThick = 66;
		}
		else if(fabs(m_dRetDn - 2000) < 0.01){
			m_nFlangeDn = 2325;
			m_nFlangeThick = 72;
		}
	}
}

CString GetDnByMat(const TCHAR* szMat)
{
	CodeBase db;
	int Number;
	CString csType, csValue, csRemark;
	XString fullFile;
    if(!FindFile(_T("DataStore.dbf"), fullFile)) {
		Callme(_T("对不起，没有发现DataStore.dbf文件！"));
		return _T("");
	}
	XDbfTable *pTable = db.Open(fullFile);
	pTable->MoveFirst();
	while(!pTable->IsEOF())	{
		GET_FIELD(pTable, _T("TypeNumber"), Number);
		GET_FIELD(pTable, _T("TypeName"), csType);
		GET_FIELD(pTable, _T("TypeValue"), csValue);
		GET_FIELD(pTable, _T("Remark"), csRemark);
		if(Number == 40 && _tcsicmp((const TCHAR*)csValue, szMat) == 0){
			return csRemark;
		}
		pTable->MoveNext();
	}
	return _T("DN");
}

BOOL SetDnByMat(const TCHAR* szMat, const TCHAR*szNewDn)
{
	CodeBase db;
	int Number;
	CString csType, csValue, csRemark;
	XString fullFile;
    if(!FindFile(_T("DataStore.dbf"), fullFile)) {
		Callme(_T("对不起，没有发现DataStore.dbf文件！"));
		return FALSE;
	}
	XDbfTable *pTable = db.Open(fullFile);
	pTable->MoveFirst();
	while(!pTable->IsEOF())	{
		GET_FIELD(pTable, _T("TypeNumber"), Number);
		GET_FIELD(pTable, _T("TypeName"), csType);
		GET_FIELD(pTable, _T("TypeValue"), csValue);
		GET_FIELD(pTable, _T("Remark"), csRemark);
		if(Number == 40 && _tcsicmp((const TCHAR*)csValue, szMat) == 0){
			SET_FIELD(pTable, _T("Remark"), szNewDn);
			return TRUE;
		}
		pTable->MoveNext();
	}
    pTable->AppendBegin();
    SET_FIELD(pTable, _T("TypeNumber"), 40);
    SET_FIELD(pTable, _T("TypeName"), _T("管径标注"));
    SET_FIELD(pTable, _T("TypeValue"), szMat);
    SET_FIELD(pTable, _T("Remark"), szNewDn);
    pTable->AppendEnd();
	return TRUE;
}

void UpdatePipeTextDim(Entity ent, CString csDnType, int nPipeDn)
{
	//更新管中文字标注
	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
		DList<AcDbObjectId> lstAttachment;
		pPipe->GetAttachments(lstAttachment);
		int len = lstAttachment.Length();
		CString csType = pPipe->GetLabel();
		int iDn = (int)pPipe->GetDnDiameter();
		XString xsDim1(_T("%s%d"), csType, iDn);
		XString xsDim2(_T("%s%d"), csDnType, nPipeDn);
		for(int m=0;m<len;m++){
			AcDbObjectId id = *lstAttachment[m];
			OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbPipeText, pDim);
			if(pDim){
				CString csText = pDim->GetText();
				if(csText.Find((const TCHAR*)xsDim2) > -1) 
					pDim->SetText((const TCHAR*)xsDim1);
			}
			OPENOBJ_END();
		}			
	}
	OPENOBJ_END();
}

void DoDimPipeDn(Entity ent, int iRadius, const TCHAR* szType, double nHeight, BOOL bIsDown, BOOL bModifyPos)
{
    if(!ent.Is(_T("ATS_PIPE")) && !ent.Is(_T("ATS_DOUBLELINEPIPE")))
        return;
 
    CString csType = szType;
    if(csType == _T("φ外径"))
        csType = _T("%%c");
	else if(csType == _T("外径壁厚"))
        csType = _T("%%c");
	else if(csType == _T("外径壁厚2")) //沈睿 2009-12-28添加 支持 中船动力专业的标注样式
	{
		TCHAR szLayer[256];
		ent.GetData(8, szLayer);
		int idx = GetPipeLayerIdxByName(szLayer);
		CString	csPipeLable = g_csPipeDim[idx];
        csType = csPipeLable + _T(" %%c");
	}
	
	CString csPn = ReadXdata(ent, _T("TG-PIPE-FLANGE-PN"));
	
	
    OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbDoubleLinePipe, pPipe);
    if(pPipe && iRadius > 0){
		int iPn=2;
		if(csPn == _T("0.25MPa"))
			iPn = 0;
		else if(csPn == _T("0.6MPa"))
			iPn = 1;
		else if(csPn == _T("1.0MPa"))
			iPn = 2;
		else if(csPn == _T("1.6MPa"))
			iPn = 3;
		double dFlangeDn(0), dFlangeThick(0);
		GetFlangeDataByDn(iPn, iRadius, dFlangeDn, dFlangeThick);
        pPipe->SetWidth(iRadius);
		pPipe->SetDnDiameter(iRadius);
        pPipe->SetFlangeDn(dFlangeDn);
        pPipe->SetFlangeThick(dFlangeThick);
    }
    OPENOBJ_END();
    
	CString csOldType;
	int iDnOld;
	double dPipeThick(0);
	AcDbObjectId idTextStyle = InitTwtTextStyle(g_csPipeDnStyle);	
    double nDnDiameter = (double)iRadius;
	OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbPipe, pPipe);
    if(!pPipe)
        return;
	csOldType = pPipe->GetLabel();
	iDnOld = (int)pPipe->GetDnDiameter();
    if(csType.Find(_T("%%c")) > -1)
	{ //用于设备给建筑提条件图，需要标注外径。不推荐用户使用，因为SetDnDiameter实体以为是DN
        int iMaterial = pPipe->GetMaterial();
        CString csMat = GetPipeMaterialByIdx(iMaterial);
		if(iRadius == 0)
			iRadius = (int)pPipe->GetDnDiameter();
		
        double nDnOut = GetPipeOutDByDn(csMat, iRadius)*1000;
        double nDnIn = GetPipeDjByDn(csMat, iRadius)*1000;
        nDnDiameter = nDnOut;
		dPipeThick = (nDnDiameter - nDnIn) / 2;
		if(_tcsicmp(szType, _T("外径壁厚")) == 0 || _tcsicmp(szType, _T("外径壁厚2")) == 0)
			pPipe->SetPipeThick(dPipeThick);
		else
			pPipe->SetPipeThick(0);
        pPipe->SetDnDiameter(nDnDiameter);
    }
    if(pPipe->IsVertical()){ //立管不标注，但把管径信息写入管
        if(iRadius > 0)
            pPipe->SetDnDiameter(nDnDiameter);
        return;
    }
	
    BOOL bIsDrawLable = pPipe->IsDrawLabel();
    if(iRadius > 0)
        pPipe->SetDnDiameter(nDnDiameter);
	
    if(!bIsDrawLable || bModifyPos){
        if(bIsDown)
            pPipe->InitLabelLocation(-g_nDnDimDist2Pipe*DocGetPScale());
        else
            pPipe->InitLabelLocation(g_nDnDimDist2Pipe*DocGetPScale());
		if(nHeight < 2.99)
		{
			if((DocGetMeterUnitDraw() && pPipe->Length() > 5) || (!DocGetMeterUnitDraw() && pPipe->Length() > DocGetPScale()/200.0))        //太短，无法标注
				pPipe->EnableDrawLabel(TRUE);
			else
				pPipe->EnableDrawLabel(FALSE);
		}
		else
		{
			if((DocGetMeterUnitDraw() && pPipe->Length() > 8) || (!DocGetMeterUnitDraw() && pPipe->Length() > DocGetPScale()/150.0))        //太短，无法标注
				pPipe->EnableDrawLabel(TRUE);
			else
				pPipe->EnableDrawLabel(FALSE);
		}
    }
	if(pPipe->GetSpare() < 0) //室外有时候不希望标注 2009-6-11
		pPipe->EnableDrawLabel(FALSE);


    pPipe->SetTextHeight(nHeight);
	double dType = pPipe->GetSpare();
	if(dType < 1)
		pPipe->SetSpare(0);
	if(_tcsicmp(szType, _T("自动")) == 0){
		int iMaterial = pPipe->GetMaterial();
		CString csMat = GetPipeMaterialByIdx(iMaterial);
		pPipe->SetLabel(GetDnByMat(csMat));
	}
	else
		pPipe->SetLabel(csType);
    pPipe->SetTextStyle(idTextStyle);
	OPENOBJ_END();
	UpdatePipeTextDim(ent, csOldType, iDnOld);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           室外部分
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//修改井编号
void ChangeWellSerial(Entity ent, const TCHAR* szNewName)
{
    OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbWell, pEquip);
    if(pEquip){
        pEquip->SetWellName(szNewName);
		if(!pEquip->IsDrawLabel())
			pEquip->EnableDrawLabel(TRUE, 1.5);
    }     
    OPENOBJ_END();  
}
  
Entity GetWellByPt(XPoint &pt, int &iPipeIdx)
{
    
 
	RBList rbMaskPipe(RTDXF0, _T("ATS_WELL"), NULL);
	PickSet ss(SS_FREE);
	XPoint ptUcs = Wcs2Ucs(pt);
	
	// 设置外包框大小
	int nLen = int(g_nWellRadius*DocGetPScale()/2);
	if (nLen == 0)
	{
		nLen = 1;
	}
	
	GetPointPickSet(ptUcs, ss, rbMaskPipe, nLen);
	
	// 过滤多余＃
	PickSet ssDel(SS_FREE);
	for (long i = 0; i < ss.Length(); i++)
	{
		Entity ent = ss[i];
		XPoint pt1;
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWell, pEquip);
		if(pEquip)
		{
			pt1 = pEquip->GetLocation();
			if (pt1.Distance2d(pt) > 1e-3)
			{
				ssDel += ent;
			}
		}
		OPENOBJ_END();
	}
	ss -= ssDel;
	
	if(ss.Length() != 1)
		return Entity();

    Entity entPipe = ss[0L];
    TCHAR szLay[256];
    entPipe.GetData(8, szLay);
    if(_tcsicmp(szLay, LAY_WELL_RAIN) == 0)
        iPipeIdx = 5;
    else if(_tcsicmp(szLay, LAY_WELL_DIRT) == 0)
        iPipeIdx = 3;
    else if(_tcsicmp(szLay, LAY_WELL_FEED) == 0)
        iPipeIdx = 0;
    else if(_tcsicmp(szLay, LAY_WELL_FIRE) == 0)
        iPipeIdx = 7;
    else if(_tcsicmp(szLay, LAY_WELL_USED) == 0)
        iPipeIdx = 6;
    else if(_tcsicmp(szLay, LAY_WELL_OTHER) == 0)
        iPipeIdx = 14;
    else if(_tcsicmp(szLay, LAY_WELL_USELESS) == 0)
        iPipeIdx = 4;
    BOOL bFlag = FALSE;
    double nRadius(0);
    XPoint ptLoc;
    OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbWell, pEquip);
    if(pEquip){
        ptLoc = pEquip->GetLocation();
        nRadius = pEquip->GetScale() * pEquip->GetPScale();
        if(fabs(ptLoc.z) > 0.001){
            ptLoc.z = 0;
            if(pEquip->upgradeOpen()==Acad::eOk){
                pEquip->SetLocation(ptLoc);
                pEquip->downgradeOpen();
            }
        }
    }
    OPENOBJ_END();
    pt.z = 0;
    double nDist = fabs(ads_distance(pt, ptLoc));
    if(nDist < nRadius)
        pt = ptLoc;
    else
        return Entity();
    return entPipe;
} 


////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           设备部分
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//得到阀门宽度
double GetValveWidth(const TCHAR* szBlockName)
{
    XPointList lstPt;
    AcDbBlockTableRecord *pRecord = NULL; 
    AcDbBlockTable* pBlockTable = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    AcDbBlockTableRecordIterator *pIterator = NULL;
    
    if(Acad::eOk != pBlockTable->getAt(szBlockName, pRecord, AcDb::kForRead)){
        pBlockTable->close();
        return -1;
    }
    if(pBlockTable)
        pBlockTable->close();
    pRecord->newIterator(pIterator);
    if(pRecord)
        pRecord->close();
    
    for(pIterator->start(); !pIterator->done(); pIterator->step()){
        AcDbEntity *pEnt;
        pIterator->getEntity(pEnt, AcDb::kForRead);
        AcDbPoint *pPoint = NULL;
        if(pPoint = AcDbPoint::cast(pEnt)){
            AcGePoint3d ptIns = pPoint->position();
            lstPt.NewAppend(ptIns);
        }
        pEnt->close();
    }
    if(pIterator)
        delete pIterator;
    if(lstPt.Length() != 2)
        return -1;
    XPoint pt1 = *lstPt[0];
    XPoint pt2 = *lstPt[1];
    return ads_distance(pt1, pt2);
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           管线公共
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 得到给水计算管径和流速的对应关系
BOOL GetRelationFromDnToV(DList<CTempStruct> &lstDn)
{
	
	XString fullFile;
	if(!FindFile(_T("datastore.dbf"), fullFile)) {
		AfxMessageBox(_T("对不起，没有发现datastore.dbf文件！"));
		return 0;
	}
	CodeBase db;
	db.read_only = 1;
	XDbfTable *pTable = db.Open(fullFile);
	if(!pTable) 
		return 0;
	int nType = 0,nRowCount = 0;
	CString strName = _T(""),strValue = _T("");
	for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext())
	{
		GET_FIELD(pTable, _T("typenumber"), nType);
		if (nType == 42)
		{
			GET_FIELD(pTable, _T("typename"), strName);
			GET_FIELD(pTable, _T("typevalue"), strValue);
			int iDn = _ttoi(strName);
			double dValue = _tstof(strValue);
			CTempStruct *pData = new CTempStruct;
			pData->m_iTmp = iDn;
			pData->m_dTmp = dValue;
			lstDn.Append(pData);


	 
		}
	}	
	return TRUE;
}

void GetPipeSpecList(DList<int> &lstSpec, const TCHAR* szMat)
{
    CodeBase db;
    XString fullFile;
    if(!FindFile(_T("pipe.dbf"), fullFile)) {
        AfxMessageBox(_T("对不起，没有发现pipe.dbf文件！"));
        return;
    }
    XDbfTable *pTable = db.Open(fullFile);
    if(!pTable) 
        return;
    CString csMaterial;
    int iDn(0);
	
    for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext()){
        GET_FIELD(pTable, _T("GC"), csMaterial);
        GET_FIELD(pTable, _T("DN"), iDn);
        if(_tcsicmp((const TCHAR*)csMaterial, szMat) == 0 ){
            int *iTmp = new int(iDn);
            lstSpec.Append(iTmp);
        }
    }
    
}

 

int GetPipeDnByQ(double nQ, AcDbObjectId id, double &nLost, double &nI, double &nSpeed, BOOL bIsReCalc)
{
    double nLength(-1);
    int nRet(-1);
    int iMat(-1);
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe){
        iMat = pPipe->GetMaterial();
        nLength = pPipe->Length();
		if(bIsReCalc)
			nRet = (int)pPipe->GetDnDiameter();
    }
    OPENOBJ_END();
	
    CString csMat = GetPipeMaterialByIdx(iMat);
    double nCh(0); // 海澄－威廉系数
    if(csMat == _T("镀锌钢管") || csMat == _T("给水铸铁管") || csMat == _T("排水铸铁管") || csMat == _T("焊接钢管") || csMat == _T("无缝钢管"))
        nCh = 100;
    else 
        nCh = 140;
    DList<int> lstSpec;
    GetPipeSpecList(lstSpec, csMat);
    // Q = 1/4 * PI * Dj * Dj * V
    nQ = nQ / 1000;
	
	if(bIsReCalc) //复算
	{
	 
		double nRetDj = GetPipeDjByDn(csMat, nRet);
		nSpeed = nQ / (0.25*PI*nRetDj*nRetDj);
		if(nRetDj < 0)
			return nRet;
		nI = 105 * (pow(nRetDj, -4.87)) * (pow(nQ, 1.85)) * (pow(nCh, -1.85)) / 10;
		nLost = nI * nLength;
	}
	else
	{
		DList<CTempStruct> lstDn;
	 
		GetRelationFromDnToV(lstDn);
	 
		lstDn.QuickSort(CTempStruct::SortByInt);

 
		// <<建筑给排水规范》2003，P35  表3.6.9
		for(int j=0;j<lstSpec.Length();j++){
			int iDnTmp = *lstSpec[j];
			double nRetDj = GetPipeDjByDn(csMat, iDnTmp);
			nSpeed = nQ / (0.25*PI*nRetDj*nRetDj);
			if(nRetDj < 0)
				continue;
			nI = 105 * (pow(nRetDj, -4.87)) * (pow(nQ, 1.85)) * (pow(nCh, -1.85)) / 10;
			nLost = nI * nLength;

			int len = lstDn.Length();
			for(int i=0;i<len;i++)
			{
				int iTmp = lstDn[i]->m_iTmp;
				double dTmp = lstDn[i]->m_dTmp;
				dTmp+= 0.001;
				if(iTmp >= iDnTmp || (iTmp == 80 && iDnTmp > 80))//if(iTmp >= iDnTmp) 2009-12-17 sr 修改。王峻发现bug，管线超过80系统就无法处理了
				{
					if(nSpeed < dTmp)
						return iDnTmp;
					break;
				}
			}

//			if(iDnTmp <= 20 && nSpeed <= 1)
//				return iDnTmp;
//			else if(iDnTmp <= 40 && iDnTmp > 20 && nSpeed <= 1.2)
//				return iDnTmp;
//			else if(iDnTmp < 80 && iDnTmp > 40 && nSpeed <= 1.5)
//				return iDnTmp;
//			else if(iDnTmp >= 80 && nSpeed <= 1.8)
//				return iDnTmp;
		}
	}
	
    return nRet;
}



BOOL GetInterPipeLevel(XPoint pt1, XPoint pt2, double nElevation, int &up, int &low)
{
    pt1 = Wcs2Ucs(pt1);
    pt2 = Wcs2Ucs(pt2);
	
    BOOL ret = FALSE;
    up = 256;
    low = 256;
    double nRotate = ads_angle(pt1, pt2);
    ads_polar(pt1, ads_angle(pt1, pt2), 20, pt1);
    ads_polar(pt2, ads_angle(pt2, pt1), 20, pt2);
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管线")), NULL);
    PickSet ss(SS_FREE);
    struct resbuf *pointlist;
 
    pointlist = ads_buildlist(RTPOINT, &pt1, RTPOINT, &pt2, NULL); 
    ss.Get(_T("F"), pointlist, NULL, rbMaskPipe);
    ads_relrb(pointlist);
    for(long i=0;i<ss.Length();i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe && !pPipe->IsVertical()){
            nElevation = pPipe->StartPoint().z; 
            if(up < pPipe->GetHideLevel() || up == 256)
                up = pPipe->GetHideLevel();
            if(low > pPipe->GetHideLevel() || low == 256)
                low = pPipe->GetHideLevel();
            ret = TRUE;
        }
        OPENOBJ_END();
    }
    return ret;
}


//得到管材列表
BOOL GetPipeMaterialList(XStringList &lstMat)
{
    CodeBase db;
    XString fullFile;
    if(!FindFile(_T("pipe.dbf"), fullFile)) {
        AfxMessageBox(_T("对不起，没有发现pipe.dbf文件！"));
        return FALSE;
    }
	
    XDbfTable *pTable = db.Open(fullFile);
    if(!pTable) 
        return FALSE;
    CString csMaterial;
    for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext()){
        GET_FIELD(pTable, _T("GC"), csMaterial);
        if(csMaterial != _T("") && lstMat.Index(csMaterial) < 0)
            lstMat.Append(tstrnew(csMaterial));
    }   
    return TRUE;
}

//给定1个管材index，返回管材名称
CString GetPipeMaterialByIdx(int idx)
{
    if(idx < 0)
        return _T("");
    XStringList lst;
    GetPipeMaterialList(lst);
    if(idx > lst.Length()){
        adsout << _T("没有发现用户自定义管材。请确认sys/pipe.dbf文件是否是最新版。\n");
        return _T("");
    }
    CString csMat = (const TCHAR*)lst[idx];
    return csMat;
}

//得到计算内径
double GetPipeDjByDn(const TCHAR* szMat, int iDnIn)
{
    double nRet((double)iDnIn/1000);
    CodeBase db;
    XString fullFile;
    if(!FindFile(_T("pipe.dbf"), fullFile)) {
        AfxMessageBox(_T("对不起，没有发现pipe.dbf文件！"));
        return nRet;
    }
    XDbfTable *pTable = db.Open(fullFile);
    if(!pTable) 
        return nRet;
    CString sMaterial;
    int iDn(0);
    double nDj(0);
    for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext()){
        GET_FIELD(pTable, _T("GC"), sMaterial);
        GET_FIELD(pTable, _T("DN"), iDn);
        GET_FIELD(pTable, _T("DJ"), nDj);
        nDj = nDj/1000;
        if(_tcsicmp((const TCHAR*)sMaterial, szMat) == 0 && iDn == iDnIn)
            return nDj;
    }
    return nRet;
}

//得到外径
double GetPipeOutDByDn(const TCHAR* szMat, int iDnIn)
{
    double nRet((double)iDnIn/1000);
    CodeBase db;
    XString fullFile;
    if(!FindFile(_T("pipe.dbf"), fullFile)) {
        AfxMessageBox(_T("对不起，没有发现pipe.dbf文件！"));
        return nRet;
    }
    XDbfTable *pTable = db.Open(fullFile);
    if(!pTable) 
        return nRet;
    CString sMaterial;
    int iDn(0);
    double nDj(0);
    for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext()){
        GET_FIELD(pTable, _T("GC"), sMaterial);
        GET_FIELD(pTable, _T("DN"), iDn);
        GET_FIELD(pTable, _T("D"), nDj);
        nDj = nDj/1000;
        if(_tcsicmp((const TCHAR*)sMaterial, szMat) == 0 && iDn == iDnIn)
            return nDj;
    }
    return nRet;
}



//得到管线2个端点
void GetPipePoint(Entity ent, XPoint &pt1, XPoint& pt2)
{
	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
		pt1 = pPipe->StartPoint();
		pt2 = pPipe->EndPoint();
	}
	OPENOBJ_END();
}

//得到管线2个端点以及中点
void GetPipePoint(Entity ent, XPoint &pt1, XPoint& pt2, XPoint &ptMid)
{
    OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe){
        pt1 = pPipe->StartPoint();
        pt2 = pPipe->EndPoint();
        if(pPipe->Is(CURVE_LINE))
            Midpoint(pt1, pt2, ptMid)
			else if(pPipe->Is(CURVE_ARC)){
            XArc arc = pPipe->GetArc();
            arc.MidPoint(ptMid);
        }
    }
    OPENOBJ_END();
}

//得到管线2个端点以及中点
Entity GetPipeByPt(XPoint pt, double &nElevation, int &iPipeSys)
{
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"),/* 8, GetLayerNames(_T("管线")),*/ NULL);
    PickSet ss(SS_FREE);
    XPoint ptUcs = Wcs2Ucs(pt);    
    GetPointPickSet(ptUcs, ss, rbMaskPipe, (int)(DocGetPScale()/2));
    double len = ss.Length();
    if(len == 0)
        return Entity();
    else if(len > 1){
        GetPointPickSet(ptUcs, ss, rbMaskPipe, (int)(DocGetPScale()/4));
    }
    if(ss.Length() != 1)
        return Entity();
    Entity entPipe = ss[0L];
    OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe && !pPipe->IsVertical()){
        nElevation = pPipe->StartPoint().z; 
        TPipeSys::SysType sys = pPipe->GetSysType();
		CString csLay = pPipe->GetLayer();
        iPipeSys = GetPipeLayerIdxByName(csLay);
    }
    else
        return Entity();
    OPENOBJ_END();
    
    return ss[0L];
}

TPipeSys::SysType GetPipeSysByLayer(const TCHAR* szLayer)
{
    CString csLayer = szLayer;
	TPipeSys::SysType sys;
	/*  cet 2011.12.9 modify
	if(csLayer == LAY_PIPE_SPRINKLE || csLayer == LAY_PIPE_SPRINKLE2 || csLayer == LAY_PIPE_SPRINKLE3 ||
	csLayer == LAY_VPIPE_SPRINKLE || csLayer == LAY_VPIPE_SPRINKLE2 || csLayer == LAY_VPIPE_SPRINKLE3)
	sys = TPipeSys::kSprinkle;
	else if(csLayer == LAY_PIPE_FIRE || csLayer == LAY_PIPE_FIRE2 || csLayer == LAY_PIPE_FIRE3 ||
	csLayer == LAY_VPIPE_FIRE || csLayer == LAY_VPIPE_FIRE2 || csLayer == LAY_VPIPE_FIRE3)
	sys = TPipeSys::kFireFighting;
	else if(csLayer == LAY_PIPE_USED || csLayer == LAY_PIPE_USED2 || csLayer == LAY_PIPE_USED3 ||
	csLayer == LAY_VPIPE_USED || csLayer == LAY_VPIPE_USED2 || csLayer == LAY_VPIPE_USED3)
	sys = TPipeSys::kUsedWater;
	else if(csLayer == LAY_PIPE_FEED || csLayer == LAY_PIPE_FEED2 || csLayer == LAY_PIPE_FEED3 ||
	csLayer == LAY_VPIPE_FEED || csLayer == LAY_VPIPE_FEED2 || csLayer == LAY_VPIPE_FEED3 )
	sys = TPipeSys::kFeedWater;
	else if(csLayer == LAY_PIPE_HEADFEED || csLayer == LAY_PIPE_HEADFEED2 || csLayer == LAY_PIPE_HEADFEED3 || 
	csLayer == LAY_VPIPE_HEADFEED || csLayer == LAY_VPIPE_HEADFEED2 || csLayer == LAY_VPIPE_HEADFEED3)
	sys = TPipeSys::kHeatFeedWater;
	else if(csLayer == LAY_PIPE_HEADBACK || csLayer == LAY_PIPE_HEADBACK2 || csLayer == LAY_PIPE_HEADBACK3 || 
	csLayer == LAY_VPIPE_HEADBACK || csLayer == LAY_VPIPE_HEADBACK2 || csLayer == LAY_VPIPE_HEADBACK3)
	sys = TPipeSys::kHeatBackWater;
	*/
	if(csLayer == LAY_PIPE_SPRINKLE || csLayer == LAY_VPIPE_SPRINKLE)
		sys = TPipeSys::kSprinkle;
	else if(csLayer == LAY_PIPE_SPRINKLE2 || csLayer == LAY_VPIPE_SPRINKLE2)
		sys = TPipeSys::kSprinkle2;
	else if(csLayer == LAY_PIPE_SPRINKLE3 || csLayer == LAY_VPIPE_SPRINKLE3)
		sys = TPipeSys::kSprinkle3;
	else if(csLayer == LAY_PIPE_FIRE || csLayer == LAY_VPIPE_FIRE)
		sys = TPipeSys::kFireFighting;
	else if(csLayer == LAY_PIPE_FIRE2 || csLayer == LAY_VPIPE_FIRE2)
		sys = TPipeSys::kFireFighting2;
	else if(csLayer == LAY_PIPE_FIRE3 || csLayer == LAY_VPIPE_FIRE3)
		sys = TPipeSys::kFireFighting3;
	else if(csLayer == LAY_PIPE_USED || csLayer == LAY_VPIPE_USED)
		sys = TPipeSys::kUsedWater;
	else if(csLayer == LAY_PIPE_USED2 || csLayer == LAY_VPIPE_USED2)
		sys = TPipeSys::kUsedWater2;
	else if(csLayer == LAY_PIPE_USED3 || csLayer == LAY_VPIPE_USED3)
		sys = TPipeSys::kUsedWater3;
	else if(csLayer == LAY_PIPE_FEED || csLayer == LAY_VPIPE_FEED)
		sys = TPipeSys::kFeedWater;
	else if(csLayer == LAY_PIPE_FEED2 || csLayer == LAY_VPIPE_FEED2)
		sys = TPipeSys::kFeedWater2;
	else if(csLayer == LAY_PIPE_FEED3 || csLayer == LAY_VPIPE_FEED3)
		sys = TPipeSys::kFeedWater3;
	else if(csLayer == LAY_PIPE_HEADFEED || csLayer == LAY_VPIPE_HEADFEED)
		sys = TPipeSys::kHeatFeedWater;
	else if(csLayer == LAY_PIPE_HEADFEED2 || csLayer == LAY_VPIPE_HEADFEED2)
		sys = TPipeSys::kHeatFeedWater2;
	else if(csLayer == LAY_PIPE_HEADFEED3 || csLayer == LAY_VPIPE_HEADFEED3)
		sys = TPipeSys::kHeatFeedWater3;
	else if(csLayer == LAY_PIPE_HEADBACK || csLayer == LAY_VPIPE_HEADBACK)
		sys = TPipeSys::kHeatBackWater;
	else if(csLayer == LAY_PIPE_HEADBACK2 || csLayer == LAY_VPIPE_HEADBACK2)
		sys = TPipeSys::kHeatBackWater2;
	else if(csLayer == LAY_PIPE_HEADBACK3 || csLayer == LAY_VPIPE_HEADBACK3)
		sys = TPipeSys::kHeatBackWater3;
	
	else if(csLayer == LAY_PIPE_DIRT || csLayer == LAY_VPIPE_DIRT)
		sys = TPipeSys::kDirtWater;
	else if(csLayer == LAY_PIPE_USELESS || csLayer == LAY_VPIPE_USELESS)
		sys = TPipeSys::kUselessWater;
	else if(csLayer == LAY_PIPE_RAIN || csLayer == LAY_VPIPE_RAIN)
		sys = TPipeSys::kRainWater;
    else if(csLayer == LAY_PIPE_COAGULATE || csLayer == LAY_VPIPE_COAGULATE)
        sys = TPipeSys::kCoagulate;
    else if(csLayer == LAY_PIPE_DRINK || csLayer == LAY_VPIPE_DRINK )
        sys = TPipeSys::kDrink;
    else if(csLayer == LAY_PIPE_PRESSDIRT || csLayer == LAY_VPIPE_PRESSDIRT)
        sys = TPipeSys::kPressDirt;
    else if(csLayer == LAY_PIPE_PRESSUSELESS || csLayer == LAY_VPIPE_PRESSUSELESS)
        sys = TPipeSys::kPressUseless;
    else if(csLayer == LAY_PIPE_PRESSRAIN || csLayer == LAY_VPIPE_PRESSRAIN)
        sys = TPipeSys::kPressRain;
    else if(csLayer == LAY_PIPE_OTHER || csLayer == LAY_VPIPE_OTHER)
        sys = TPipeSys::kOther;
	else if(csLayer == LAY_PIPE_USER1 || csLayer == LAY_VPIPE_USER1)
        sys = TPipeSys::kCivilFeed;
	else if(csLayer == LAY_PIPE_USER2 || csLayer == LAY_VPIPE_USER2)
        sys = TPipeSys::kCycleFeed;
	else if(csLayer == LAY_PIPE_USER3 || csLayer == LAY_VPIPE_USER3) // cet 2011.12.1 add kUer3 - kUser8
        sys = TPipeSys::kUser3;
	else if(csLayer == LAY_PIPE_USER4 || csLayer == LAY_VPIPE_USER4)
        sys = TPipeSys::kUser4;
	else if(csLayer == LAY_PIPE_USER5 || csLayer == LAY_VPIPE_USER5)
        sys = TPipeSys::kUser5;
	else if(csLayer == LAY_PIPE_USER6 || csLayer == LAY_VPIPE_USER6)
        sys = TPipeSys::kUser6;
	else if(csLayer == LAY_PIPE_USER7 || csLayer == LAY_VPIPE_USER7)
        sys = TPipeSys::kUser7;
	else if(csLayer == LAY_PIPE_USER8 || csLayer == LAY_VPIPE_USER8)
        sys = TPipeSys::kUser8;
	else
		sys = TPipeSys::kUnknownSys;
	return sys;
}

extern BOOL IsExistLayer(const TCHAR* szLayer);
//已知管线图层名称，返回管线类别INDEX
int GetPipeLayerIdxByName(const TCHAR* szLayer)
{ 
    CString csLayer;
	csLayer = (const TCHAR*)szLayer;
	
	int ret = 0;
	if(csLayer == LAY_PIPE_FEED || csLayer == LAY_VPIPE_FEED)
		ret = 0;
	else if(csLayer == LAY_PIPE_HEADFEED || csLayer == LAY_VPIPE_HEADFEED)
		ret = 1;
	else if(csLayer == LAY_PIPE_HEADBACK || csLayer == LAY_VPIPE_HEADBACK)
		ret = 2;
	else if(csLayer == LAY_PIPE_DIRT || csLayer == LAY_VPIPE_DIRT)
		ret = 3;
	else if(csLayer == LAY_PIPE_USELESS || csLayer == LAY_VPIPE_USELESS)
		ret = 4;
	else if(csLayer == LAY_PIPE_RAIN || csLayer == LAY_VPIPE_RAIN)
		ret = 5;
	else if(csLayer == LAY_PIPE_USED || csLayer == LAY_VPIPE_USED)
		ret = 6;
	else if(csLayer == LAY_PIPE_FIRE || csLayer == LAY_VPIPE_FIRE)
		ret = 7;
	else if(csLayer == LAY_PIPE_SPRINKLE || csLayer == LAY_VPIPE_SPRINKLE)
		ret = 8;
    else if(csLayer == LAY_PIPE_COAGULATE || csLayer == LAY_VPIPE_COAGULATE)
        ret = 9;
    else if(csLayer == LAY_PIPE_DRINK || csLayer == LAY_VPIPE_DRINK)
        ret = 10;
    else if(csLayer == LAY_PIPE_PRESSDIRT || csLayer == LAY_VPIPE_PRESSDIRT)
        ret = 11;
    else if(csLayer == LAY_PIPE_PRESSUSELESS || csLayer == LAY_VPIPE_PRESSUSELESS)
        ret = 12;
    else if(csLayer == LAY_PIPE_PRESSRAIN || csLayer == LAY_VPIPE_PRESSRAIN)
        ret = 13;
    else if(csLayer == LAY_PIPE_OTHER || csLayer == LAY_VPIPE_OTHER)
        ret = 14;
    else if(csLayer == LAY_PIPE_USER1 || csLayer == LAY_VPIPE_USER1)
        ret = 15;
    else if(csLayer == LAY_PIPE_USER2 || csLayer == LAY_VPIPE_USER2)
        ret = 16;
    else if(csLayer == LAY_PIPE_FEED2 || csLayer == LAY_VPIPE_FEED2)
        ret = 17;
    else if(csLayer == LAY_PIPE_FEED3 || csLayer == LAY_VPIPE_FEED3)
        ret = 18;
    else if(csLayer == LAY_PIPE_HEADFEED2 || csLayer == LAY_VPIPE_HEADFEED2)
        ret = 19;
    else if(csLayer == LAY_PIPE_HEADFEED3 || csLayer == LAY_VPIPE_HEADFEED3)
        ret = 20;
    else if(csLayer == LAY_PIPE_HEADBACK2 || csLayer == LAY_VPIPE_HEADBACK2)
        ret = 21;
    else if(csLayer == LAY_PIPE_HEADBACK3 || csLayer == LAY_VPIPE_HEADBACK3)
        ret = 22;
    else if(csLayer == LAY_PIPE_FIRE2 || csLayer == LAY_VPIPE_FIRE2)
        ret = 23;
    else if(csLayer == LAY_PIPE_FIRE3 || csLayer == LAY_VPIPE_FIRE3)
        ret = 24;
    else if(csLayer == LAY_PIPE_SPRINKLE2 || csLayer == LAY_VPIPE_SPRINKLE2)
        ret = 25;
    else if(csLayer == LAY_PIPE_SPRINKLE3 || csLayer == LAY_VPIPE_SPRINKLE3)
        ret = 26;
    else if(csLayer == LAY_PIPE_USED2 || csLayer == LAY_VPIPE_USED2)
        ret = 27;
    else if(csLayer == LAY_PIPE_USED3 || csLayer == LAY_VPIPE_USED3)
        ret = 28;
	else if (csLayer == LAY_VPIPE_USER3 || csLayer == LAY_PIPE_USER3) // cet 2011.12.1 add 29 - 34
		ret = 29;
	else if (csLayer == LAY_VPIPE_USER4 || csLayer == LAY_PIPE_USER4)
		ret = 30;
	else if (csLayer == LAY_VPIPE_USER5 || csLayer == LAY_PIPE_USER5)
		ret = 31;
	else if (csLayer == LAY_VPIPE_USER6 || csLayer == LAY_PIPE_USER6)
		ret = 32;
	else if (csLayer == LAY_VPIPE_USER7 || csLayer == LAY_PIPE_USER7)
		ret = 33;
	else if (csLayer == LAY_VPIPE_USER8 || csLayer == LAY_PIPE_USER8)
		ret = 34;
	else
		ret = -1;
	return ret;
}


/*
//已知管线类别，返回管线名称
CString GetPipeNameBySys(TPipeSys::SysType sys)
{
    CString csRet;
    if(sys == TPipeSys::kFeedWater)
        csRet = _T("给水");
    else if(sys == TPipeSys::kHeatFeedWater)
        csRet = _T("热给水");
    else if(sys == TPipeSys::kHeatBackWater)
        csRet = _T("热回水");
    else if(sys == TPipeSys::kDirtWater)
        csRet = _T("污水");
    else if(sys == TPipeSys::kUselessWater)
        csRet = _T("废水");
    else if(sys == TPipeSys::kRainWater)
        csRet = _T("雨水");
    else if(sys == TPipeSys::kUsedWater)
        csRet = _T("中水");
    else if(sys == TPipeSys::kFireFighting)
        csRet = _T("消防");
    else if(sys == TPipeSys::kSprinkle)
        csRet = _T("喷淋");
    else if(sys == TPipeSys::kCoagulate)
        csRet = _T("凝结");
    else if(sys == TPipeSys::kDrink)
        csRet = _T("直饮");
    else if(sys == TPipeSys::kPressDirt)
        csRet = _T("压力污");
    else if(sys == TPipeSys::kPressUseless)
        csRet = _T("压力废");
    else if(sys == TPipeSys::kPressRain)
        csRet = _T("压力雨");
    else if(sys == TPipeSys::kOther)
        csRet = _T("其它管");
	
    return csRet;
}

//已知管线类别，返回管线类别INDEX sr 2008-9-16 取消
int GetPipeLayerIdxBySys(TPipeSys::SysType sys)
{
    int iRet(0);
    if(sys == TPipeSys::kFeedWater)
        iRet = 0;
    else if(sys == TPipeSys::kHeatFeedWater)
        iRet = 1;
    else if(sys == TPipeSys::kHeatBackWater)
        iRet = 2;
    else if(sys == TPipeSys::kDirtWater)
        iRet = 3;
    else if(sys == TPipeSys::kUselessWater)
        iRet = 4;
    else if(sys == TPipeSys::kRainWater)
        iRet = 5;
    else if(sys == TPipeSys::kUsedWater)
        iRet = 6;
    else if(sys == TPipeSys::kFireFighting)
        iRet = 7;
    else if(sys == TPipeSys::kSprinkle)
        iRet = 8;
    else if(sys == TPipeSys::kCoagulate)
        iRet = 9;
    else if(sys == TPipeSys::kDrink)
        iRet = 10;
    else if(sys == TPipeSys::kPressDirt)
        iRet = 11;
    else if(sys == TPipeSys::kPressUseless)
        iRet = 12;
    else if(sys == TPipeSys::kPressRain)
        iRet = 13;
    else if(sys == TPipeSys::kOther)
        iRet = 14;
    return iRet;
}
*/

int GetPipeLayerIdxBySys(TPipeSys::SysType sys)
{
    int iRet = -1;
    if(sys == TPipeSys::kFeedWater)
        iRet = 0;
    else if(sys == TPipeSys::kHeatFeedWater)
        iRet = 1;
    else if(sys == TPipeSys::kHeatBackWater)
        iRet = 2;
    else if(sys == TPipeSys::kDirtWater)
        iRet = 3;
    else if(sys == TPipeSys::kUselessWater)
        iRet = 4;
    else if(sys == TPipeSys::kRainWater)
        iRet = 5;
    else if(sys == TPipeSys::kUsedWater)
        iRet = 6;
    else if(sys == TPipeSys::kFireFighting)
        iRet = 7;
    else if(sys == TPipeSys::kSprinkle)
        iRet = 8;
    else if(sys == TPipeSys::kCoagulate)
        iRet = 9;
    else if(sys == TPipeSys::kDrink)
        iRet = 10;
    else if(sys == TPipeSys::kPressDirt)
        iRet = 11;
    else if(sys == TPipeSys::kPressUseless)
        iRet = 12;
    else if(sys == TPipeSys::kPressRain)
        iRet = 13;
    else if(sys == TPipeSys::kOther)
        iRet = 14;
	else if(sys == TPipeSys::kCivilFeed)
        iRet = 15;
    else if(sys == TPipeSys::kCycleFeed)
        iRet = 16;
    else if(sys == TPipeSys::kFeedWater2)
        iRet = 17;
    else if(sys == TPipeSys::kFeedWater3)
        iRet = 18;
    else if(sys == TPipeSys::kHeatFeedWater2)
        iRet = 19;
    else if(sys == TPipeSys::kHeatFeedWater3)
        iRet = 20;
    else if(sys == TPipeSys::kHeatBackWater2)
        iRet = 21;
    else if(sys == TPipeSys::kHeatBackWater3)
        iRet = 22;
    else if(sys == TPipeSys::kFireFighting2)
        iRet = 23;
    else if(sys == TPipeSys::kFireFighting3)
        iRet = 24;
    else if(sys == TPipeSys::kSprinkle2)
        iRet = 25;
    else if(sys == TPipeSys::kSprinkle3)
        iRet = 26;
    else if(sys == TPipeSys::kUsedWater2)
        iRet = 27;
    else if(sys == TPipeSys::kUsedWater3)
        iRet = 28;
    else if(sys == TPipeSys::kUser3)
        iRet = 29;
    else if(sys == TPipeSys::kUser4)
        iRet = 30;
    else if(sys == TPipeSys::kUser5)
        iRet = 31;
    else if(sys == TPipeSys::kUser6)
        iRet = 32;
    else if(sys == TPipeSys::kUser7)
        iRet = 33;
    else if(sys == TPipeSys::kUser8)
        iRet = 34;
    return iRet;
}

CString GetPipeNameBySys(TPipeSys::SysType sys)
{
    CString sRet;
    if(sys == TPipeSys::kFeedWater)
        sRet = _T("给水");
	else if(sys == TPipeSys::kFeedWater2)
        sRet = _T("给水中");
	else if(sys == TPipeSys::kFeedWater3)
        sRet = _T("给水高");
    else if(sys == TPipeSys::kHeatFeedWater)
        sRet = _T("热给水");
	else if(sys == TPipeSys::kHeatFeedWater2)
        sRet = _T("热给水中");
	else if(sys == TPipeSys::kHeatFeedWater3)
        sRet = _T("热给水高");
    else if(sys == TPipeSys::kHeatBackWater)
        sRet = _T("热回水");
	else if(sys == TPipeSys::kHeatBackWater2)
        sRet = _T("热回水中");
	else if(sys == TPipeSys::kHeatBackWater3)
        sRet = _T("热回水高");
    else if(sys == TPipeSys::kDirtWater)
        sRet = _T("污水");
    else if(sys == TPipeSys::kUselessWater)
        sRet = _T("废水");
    else if(sys == TPipeSys::kRainWater)
        sRet = _T("雨水");
    else if(sys == TPipeSys::kUsedWater)
        sRet = _T("中水");
	else if(sys == TPipeSys::kUsedWater2)
        sRet = _T("中水中");
	else if(sys == TPipeSys::kUsedWater3)
        sRet = _T("中水高");
    else if(sys == TPipeSys::kFireFighting)
        sRet = _T("消防");
	else if(sys == TPipeSys::kFireFighting2)
        sRet = _T("消防中");
	else if(sys == TPipeSys::kFireFighting3)
        sRet = _T("消防高");
    else if(sys == TPipeSys::kSprinkle)
        sRet = _T("喷淋");
	else if(sys == TPipeSys::kSprinkle2)
        sRet = _T("喷淋中");
	else if(sys == TPipeSys::kSprinkle3)
        sRet = _T("喷淋高");
	else if(sys == TPipeSys::kOther)
        sRet = _T("其它管");
    else if(sys == TPipeSys::kCoagulate)
   	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("凝结");
		} 
	}
    else if(sys == TPipeSys::kDrink)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("直饮");
		} 
	}
    else if(sys == TPipeSys::kPressDirt)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("压力污");
		} 
	}
    else if(sys == TPipeSys::kPressUseless)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("压力废");
		} 
	}
    else if(sys == TPipeSys::kPressRain)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("压力雨");
		} 
	}
	else if (sys == TPipeSys::kCivilFeed)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户1管线");
		} 
	}
	else if (sys == TPipeSys::kCycleFeed)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户2管线");
		} 
	}
	else if (sys == TPipeSys::kUser3)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户3管线");
		} 
	}
	else if (sys == TPipeSys::kUser4)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户4管线");
		} 
	}
	else if (sys == TPipeSys::kUser5)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户5管线");
		} 
	}
	else if (sys == TPipeSys::kUser6)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户6管线");
		} 
	}
	else if (sys == TPipeSys::kUser7)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户7管线");
		} 
	}
	else if (sys == TPipeSys::kUser8)
	{
		int nIndex = GetPipeLayerIdxBySys(sys);
		CString sLayer = GetPipeLayerByIdx(nIndex);
		if (!GetLayerReMark(sLayer, sRet))
		{
			sRet = _T("用户8管线");
		} 
	}
    return sRet;
}


//已知管线类别INDEX，返回管线图层名称
CString GetPipeLayerByIdx(int iLayer)
{
    if(iLayer > 34 || iLayer < 0)
        return CString();
    CString csLayer[] = {LAY_PIPE_FEED, LAY_PIPE_HEADFEED, LAY_PIPE_HEADBACK, LAY_PIPE_DIRT,
						LAY_PIPE_USELESS, LAY_PIPE_RAIN, LAY_PIPE_USED, LAY_PIPE_FIRE, LAY_PIPE_SPRINKLE,
						LAY_PIPE_COAGULATE, LAY_PIPE_DRINK, LAY_PIPE_PRESSDIRT, LAY_PIPE_PRESSUSELESS, 
						LAY_PIPE_PRESSRAIN, LAY_PIPE_OTHER, LAY_PIPE_USER1, LAY_PIPE_USER2, 
						LAY_PIPE_FEED2,LAY_PIPE_FEED3, LAY_PIPE_HEADFEED2,LAY_PIPE_HEADFEED3,
						LAY_PIPE_HEADBACK2,LAY_PIPE_HEADBACK3,LAY_PIPE_FIRE2,LAY_PIPE_FIRE3,
						LAY_PIPE_SPRINKLE2,LAY_PIPE_SPRINKLE3,LAY_PIPE_USED2,LAY_PIPE_USED3,
						LAY_PIPE_USER3, LAY_PIPE_USER4, LAY_PIPE_USER5, LAY_PIPE_USER6, LAY_PIPE_USER7, // cet 2011.12.1 add user3-user8
						LAY_PIPE_USER8,
						};
	return csLayer[iLayer];
}

//初始化给排水管线图层
AcDbObjectId InitPipeLayer(const TCHAR* szLay)
{
    AcDbObjectId id = NULL;
    if(!IsExistLayer(szLay)){
        id = InitLayer(szLay);
        int idx = GetPipeLayerIdxByName(szLay);
        if(idx > -1)
            SetLayerLineType(szLay, g_csTwtLineType[idx]);
    }
    else
        id = InitLayer(szLay);
    return id;
}




////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           公共部分
////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//已知图块名称，返回图块记录id
AcDbObjectId GetBlkIdByName(const TCHAR* szBlkName)
{
    return GetBlockIdFromString(szBlkName);
}

//已知图块记录id，返回图块名称
CString GetBlkNameById(AcDbObjectId id)
{
	CString csBlkName;
	const TCHAR *szBlkName = NULL;
	OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbBlockTableRecord, pRecord);
	if(pRecord)
		pRecord->getName(szBlkName);
	OPENOBJ_END();
	csBlkName = szBlkName;
	return csBlkName;
}


//调用图库
BOOL InvokeTkwMan(const TCHAR *pszLib, BOOL bSelOnly, XString &sBlockName)
{
    if(!AT_loaded(_T("wfB"))) {
        int nRet=acrxLoadModule(_T("wfB.arx"), Adesk::kTrue, true);
        if(!nRet)
            return FALSE;
    }
    int nCode=bSelOnly? RTT : RTNIL;
    RBList rbCmd=ads_buildlist(RTSTR, _T("ITkw"), RTSTR, pszLib, nCode, 
        RTSTR, (const TCHAR *)sBlockName, NULL);
    resbuf *rbRes=NULL;
    if(ads_invoke(rbCmd, &rbRes)==RTNORM && rbRes) {
        if(rbRes && rbRes->restype==RTSTR)
            sBlockName=rbRes->resval.rstring;
        ads_relrb(rbRes);
        return TRUE;
    }
    return FALSE;
}

//得到图块的宽度，长度
BOOL GetBlkRecordWidth(const TCHAR* szBlkName, double nScaleX, double nScaleY, double &nWidth, double &nHeight)
{
    AcDbBlockReference *pBlkRef = new AcDbBlockReference();
    AcDbBlockTable* pBlockTable = NULL;
    AcDbObjectId recordId = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(Acad::eOk != pBlockTable->getAt(szBlkName, recordId, AcDb::kForRead)){
        pBlockTable->close();
        delete pBlkRef;
        return FALSE;
    }
    XPoint pt;
    pBlockTable->close();
    pBlkRef->setBlockTableRecord(recordId);
    pBlkRef->setPosition(pt);
    pBlkRef->setRotation(0);
    pBlkRef->setScaleFactors(AcGeScale3d(nScaleX, nScaleY, 1));
    AcDbExtents extents;
    pBlkRef->getGeomExtents(extents);
    AcGePoint3d ptMax = extents.maxPoint();
    AcGePoint3d ptMin = extents.minPoint();
    double dWidth = (ptMax.x-ptMin.x)/2;
    double dHeight = (ptMax.y-ptMin.y)/2;
    if(dWidth < dHeight){
        nWidth = dWidth;
        nHeight = dHeight;
    }
    else{
        nWidth = dHeight;
        nHeight = dWidth;
    }
	
    delete pBlkRef;
    return TRUE;
}

//给定1个点，返回它所在曲线上的角度
double GetInsRotate(XPoint ptIns, XCurveSegment seg)
{
    if(seg.Is(CURVE_LINE)){
        double ang = ads_angle(seg.StartPoint(), seg.EndPoint());
        if(ang > PI)
            ang -= PI;
        return ang;
    }
    else if(seg.Is(CURVE_ARC)){
        XArc arc = seg.GetArc();
        double angle = ads_angle(ptIns, arc.GetCenterPt());
        angle -= PI/2;
        return angle;
    }
    else if(seg.Is(CURVE_CIRCLE)){
        XCircle cir = seg.GetCircle();
        double angle = ads_angle(ptIns, cir.GetCenterPt());
        angle -= PI/2;
        return angle;
    }
    return 0;
}

//选取外部参照上1根曲线
XCurveSegment GetExternalBlockSeg(Entity entBlk, XPoint &ptPick)
{
    XBlock myBlock(entBlk);
    if(!myBlock.m_bInitSuccess)
        return XCurveSegment();
	
    XCurveSegment seg;
    ads_point ptResult;
    ads_name ent;
    ads_matrix xformres;
    resbuf* refstkres;
    while (1) {
        refstkres = NULL;
        //直接选择子实体
		int result = acedNEntSelP(_T("\n外部参照！请继续选择外部参照上墙线<退出>: "), ent, ptResult, 0, xformres, &refstkres);
        if (refstkres != NULL)
            acutRelRb(refstkres);
        if (result == RTNORM) {
            Entity entTemp = ent;
            if(entTemp.Is(_T("LINE"))){
                ptPick = ptResult;
                XCurveSegment seg2(entTemp);
                AcGePoint3d ptStart = seg2.StartPoint();
                ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
                AcGePoint3d ptEnd = seg2.EndPoint();
                ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
                XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
                seg = line;
                return seg;
            }
            else if(entTemp.Is(_T("ATS_WALL"))){
                OPENOBJ_BEGIN(entTemp, AcDb::kForRead, TDbWall, pWall);
                XCurveSegment lCurve, rCurve;
                XPoint ptNew1, ptNew2;
                if(pWall) {
                    ptPick = ptResult;
                    pWall->GetSideCurve(lCurve, rCurve);
                    lCurve.ProjectToMe(ptPick, ptNew1);
                    rCurve.ProjectToMe(ptPick, ptNew2);
                    if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2))
                        seg = lCurve;
                    else
                        seg = rCurve;
                    AcGePoint3d ptStart = seg.StartPoint();
                    ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
                    AcGePoint3d ptEnd = seg.EndPoint();
                    ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
                    XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
                    seg = line;
                    return seg;
                }
                OPENOBJ_END();
            }
        }
        else
            break;
    }
    return seg;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           生成系统图
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//克隆的时候，把所有的附件也克隆了
//导致的后果:
//如果取消系统生成，新管线删除了，而他记录的附件（实际不是他的）也被删除了
//所以这里手工把附件记录删除

TDbPipe * ClonePipe(TDbPipe *pOldPipe)
{
	TDbPipe *pNewPipe = (TDbPipe *)pOldPipe->clone();
	DList<AcDbObjectId> lstAttachment;
	pNewPipe->GetAttachments(lstAttachment);
	for(int n=0;n<lstAttachment.Length();n++){
		AcDbObjectId idTmp = *lstAttachment[n];
		pNewPipe->RemoveAttachment(idTmp);
	}	
	return pNewPipe;
}

CString GetSysBlockByAng(const TCHAR* szOld, double angEq, BOOL &bIsBreak)
{
    if(_tcsicmp(szOld, _T("")) == 0)
        return CString();
	CString csRet, csDesName, csTKName, csAllTk;
	XString xsTKName, xsRocord;
	SplitSlbName(szOld, xsTKName, xsRocord);
	csTKName = xsTKName;
    csAllTk.Format(_T("%s%s.tk"), g_csDwbPath, (const TCHAR*)xsTKName);
	
	
	csDesName = GetBlkDesName((const TCHAR*)xsRocord, (const TCHAR*)csAllTk);
	if(csDesName.Find(_T("(打断)"), 0) >= 0) // 2008-3-21 沈睿修改，默认都是打断管线
		bIsBreak = TRUE;
	else
		bIsBreak = FALSE;
	if(csDesName.Find(_T("-"), 0) < 0)
		return CString(szOld);
	csDesName = csDesName.Right(8);  // 180度
	if(angEq > 2*PI)
		angEq -= 2*PI;
    else if(fabs(angEq - 2*PI) < 0.01)
		angEq = 0;
	if(angEq < (PI/2-0.00001) && (angEq > 0 || fabs(angEq) < 0.01)){           //0
		csDesName = GetBlkDesName((const TCHAR*)csDesName, (const TCHAR*)csAllTk);
		csDesName = csDesName.Right(8);
		csDesName = GetBlkDesName((const TCHAR*)csDesName, (const TCHAR*)csAllTk);
		csDesName = csDesName.Right(8);
		csRet = csDesName;
	}
	else if(angEq < (PI - 0.01) && angEq >= (PI/2-0.00001)){     //90
		csDesName = GetBlkDesName((const TCHAR*)csDesName, (const TCHAR*)csAllTk);
		csDesName = csDesName.Right(8);
		csDesName = GetBlkDesName((const TCHAR*)csDesName, (const TCHAR*)csAllTk);
		csDesName = csDesName.Right(8);
		csDesName = GetBlkDesName((const TCHAR*)csDesName, (const TCHAR*)csAllTk);
		csDesName = csDesName.Right(8);
		csRet = csDesName;
	}
	else if((angEq + 0.01) < PI/2*3 && (angEq > PI || fabs(angEq - PI) < 0.01)){   //180
		csRet = csDesName;
	}
	else if(angEq < PI*2 && (angEq > PI/2*3 || fabs(angEq - PI/2*3) < 0.01)){ //270
		csDesName = GetBlkDesName((const TCHAR*)csDesName, (const TCHAR*)csAllTk);
		csDesName = csDesName.Right(8);
		csRet = csDesName;
	}
	if(csRet != _T(""))
		csRet = csTKName + _T("(") + csRet + _T(")");
	return csRet;
}

BOOL IsHorAngle(double nAngle)
{
	//if(nAngle >= PI*2)
	if(fabs(nAngle - PI*2) < 0.00001 || nAngle > PI*2)
		nAngle -= PI*2;
	if(fabs(nAngle) < 0.00001 || fabs(nAngle - PI) < 0.00001)
		return TRUE;
	else
		return FALSE;
}


void PlanEquip2Sys(AcDbObjectId id, TDbPipe *pPipe, double nRadian, AcGeMatrix3d mat, AcGeScale3d scale)
{
	if(!pPipe || !id)
		return;
	XPoint ptStart, ptEnd, ptNewS, ptNewE, ptInsert;
	double dX = scale.sx;
	double dY = scale.sy;
	double dZ = scale.sz;
	
	if(IsWell(id))
	{
		TDbWell *pNewWell = NULL;
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWell, pEquip);
		if(pEquip){
			ptStart = pEquip->GetLocation();
			pNewWell = (TDbWell *)pEquip->clone();
		}
		OPENOBJ_END();
		ptStart.TransformBy(mat); 

		ptStart = Wcs2Ucs(ptStart); // sr 2010-1-28 modify 系统生成支持UCS
		ptNewS.x = ptStart.x*dX + cos(nRadian)*ptStart.y*dY;
		ptNewS.y = ptStart.z*dZ + sin(nRadian)*ptStart.y*dY;
		ptNewS = Ucs2Wcs(ptNewS);  // sr 2010-1-28 modify 系统生成支持UCS
		
		pNewWell->SetLocation(ptNewS);
		pNewWell->SetInsert(ptNewS);
		pNewWell->EnableDrawLabel(FALSE);
		pNewWell->SetHidePipe(TRUE);
	//	pNewWell->SetLabelLocation(ptNewS);
	//	pNewWell->SetHidePipe(FALSE);
		
		AddToCurrentSpace(pNewWell, Adesk::kTrue);
		return;
	}
	// 泵 cet 2017.12.28 add
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPump, pPump);
	if (pPump != NULL)
	{
		XPoint ptLoc = pPump->GetLocation();		
		ptLoc.TransformBy(mat); 
		ptLoc = Wcs2Ucs(ptLoc); // 系统生成支持UCS
		XPoint pt;
		pt.x = ptLoc.x*dX + cos(nRadian)*ptLoc.y*dY;
		pt.y = ptLoc.z*dZ + sin(nRadian)*ptLoc.y*dY;
		pt = Ucs2Wcs(pt);   // 系统生成支持UCS
		if (_tcsicmp(pPump->GetBlockFront(), _T("")) != 0)
		{
			TCHAR *pszLayer = pPump->layer();
			TCHAR szLayer[256];
			_tcscpy(szLayer, pszLayer);
			delete[] pszLayer;
			InsertBlock(pPump->GetBlockFront(), pt, pPump->GetPumpLength() * dX, pPump->GetPumpLength() * dY, Ucs2Wcs(0.0), szLayer);
		}
		return;
	}
	OPENOBJ_END();

    XString xsTmpSys;
	TDbEquipment *pNewEquip = NULL;
 
	BOOL bIsBreak = TRUE;
	AcDbObjectId sysBlkId(NULL);
  
	CString csBlkName, csSysBlk, csDesName;
    int iItem;
    GetEquipNameById(id, csBlkName, csDesName, iItem);
    
	double angEq(0), nRotateNewEq(0), nPipeLength(0);
	// cet 2012.6.21 add 读取设备管径信息
	ads_name name;
	acdbGetAdsName(name, id);
	Entity ent(name);
	CString sPipeDn;
	sPipeDn = ReadXdata(ent, _T("LINKINGPIPE_DN"));
	if (sPipeDn.IsEmpty())
	{
		sPipeDn = _T("25");
	}
	double dPipeDn = _tstof(sPipeDn);

	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbEquipment, pEquip);
	if(pEquip){
		ptStart = pEquip->GetLocation();
		//ptStart = pEquip->GetInsert();
		ptInsert = ptStart;
		nPipeLength = pEquip->GetPipeLength();
		AcDbObjectId idBlk = pEquip->GetBlock2d();
		csBlkName = GetBlkNameById(idBlk);
		csSysBlk = pEquip->GetSysBlock();
        angEq = pEquip->GetAngle();
		if(csSysBlk == _T("") && _tcsicmp(_T("$TWTSYS$00000320"), csBlkName) == 0) 
			return;//对于热水给水点(十字叉), 如果系统图块为空,就不生成了, 由给水生成
		pNewEquip = (TDbEquipment *)pEquip->clone();
	}
	OPENOBJ_END();
	ptStart.TransformBy(mat); 
	ptStart = Wcs2Ucs(ptStart); // sr 2010-1-28 modify 系统生成支持UCS
	
	csSysBlk = GetSysBlockByAng(csSysBlk, angEq, bIsBreak);
    
	if(LoadDwbBlock((const TCHAR*)csSysBlk, xsTmpSys) == RTNORM){
		sysBlkId = GetBlkIdByName((const TCHAR*)xsTmpSys);
		pNewEquip->SetBlock2d(sysBlkId);
	}	

	if(fabs(nPipeLength) > 0.001){
		if(_tcsicmp(_T("$TWTSYS$00000128"), csBlkName) == 0){  //上下喷头
			ptEnd = ptStart;
			ptEnd.z -= nPipeLength;
			ptNewS.x = ptStart.x*dX + cos(nRadian)*ptStart.y*dY;
			ptNewS.y = ptStart.z*dZ + sin(nRadian)*ptStart.y*dY;
			ptNewE.x = ptEnd.x*dX + cos(nRadian)*ptEnd.y*dY;
			ptNewE.y = ptEnd.z*dZ + sin(nRadian)*ptEnd.y*dY;
			ptNewS = Ucs2Wcs(ptNewS);    // sr 2010-1-28 modify 系统生成支持UCS
			ptNewE = Ucs2Wcs(ptNewE);    // sr 2010-1-28 modify 系统生成支持UCS
			
			TDbPipe *pNewPipe = ClonePipe(pPipe);
            pNewPipe->EnableDrawLabel(FALSE);
         // pNewPipe->SetDnDiameter(25); cet 2012.6.21 modify
			pNewPipe->SetDnDiameter(dPipeDn);
			pNewPipe->SetStartPoint(ptNewS);
			pNewPipe->SetEndPoint(ptNewE);
            pNewPipe->SetHideLevel(1);
            pNewPipe->SetModelType(TPipeSys::kSystem);
			AddToCurrentSpace(pNewPipe, Adesk::kTrue);
			TDbEquipment *pNewEquip2 = NULL;
			pNewEquip2 = (TDbEquipment *)pNewEquip->clone();
			ptNewS.x = ptEnd.x*dX + cos(nRadian)*ptEnd.y*dY;
			ptNewS.y = ptEnd.z*dZ + sin(nRadian)*ptEnd.y*dY;
			ptNewS = Ucs2Wcs(ptNewS);    // sr 2010-1-28 modify 系统生成支持UCS
			
			pNewEquip2->SetSysBlock(_T(""));
			pNewEquip2->SetHidePipe(bIsBreak);
			pNewEquip2->SetAngle(Ucs2Wcs(0.0));// sr 2010-1-28 modify 系统生成支持UCS
			pNewEquip2->SetLocation(ptNewS);
            pNewEquip2->SetInsert(ptNewS);
			AddToCurrentSpace(pNewEquip2, Adesk::kTrue);
		}
		else if(_tcsicmp(_T("$TWTSYS$00000131"), csBlkName) == 0){//侧喷头
			ptEnd = ptStart;
			ptEnd.z += nPipeLength;
			ptNewS.x = ptEnd.x*dX + cos(nRadian)*ptEnd.y*dY;
			ptNewS.y = ptEnd.z*dZ + sin(nRadian)*ptEnd.y*dY;
			ptNewE = ptNewS;
			ptNewE.x -= nPipeLength/2;//往右画
			ptNewS = Ucs2Wcs(ptNewS);    // sr 2010-1-28 modify 系统生成支持UCS
			ptNewE = Ucs2Wcs(ptNewE);    // sr 2010-1-28 modify 系统生成支持UCS
			
		//	TDbPipe *pNewPipe3 = (TDbPipe *)pPipe->clone();
			TDbPipe *pNewPipe3 = ClonePipe(pPipe);
         // pNewPipe3->SetDnDiameter(25); cet 2012.6.21 modify
			pNewPipe3->SetDnDiameter(dPipeDn);
            pNewPipe3->EnableDrawLabel(FALSE);
			pNewPipe3->SetStartPoint(ptNewS);
			pNewPipe3->SetEndPoint(ptNewE);
            pNewPipe3->SetHideLevel(1);
            pNewPipe3->SetModelType(TPipeSys::kSystem);
			AddToCurrentSpace(pNewPipe3, Adesk::kTrue);
			nRotateNewEq = PI/2;
			
		}

		ptEnd = ptStart;
		ptEnd.z += nPipeLength;
		ptNewS.x = ptStart.x*dX + cos(nRadian)*ptStart.y*dY;
		ptNewS.y = ptStart.z*dZ + sin(nRadian)*ptStart.y*dY;
		ptNewE.x = ptEnd.x*dX + cos(nRadian)*ptEnd.y*dY;
		ptNewE.y = ptEnd.z*dZ + sin(nRadian)*ptEnd.y*dY;
	
		ptNewS = Ucs2Wcs(ptNewS);    // sr 2010-1-28 modify 系统生成支持UCS
		ptNewE = Ucs2Wcs(ptNewE);    // sr 2010-1-28 modify 系统生成支持UCS
		
		TDbPipe *pNewPipe = ClonePipe(pPipe);
//      cet 2012.6.21 modify
//      if(_tcsicmp(_T("TWTSYS(00000283)"), csSysBlk) == 0 || _tcsicmp(_T("TWTSYS(00000126)"), csSysBlk) == 0)
//          pNewPipe->SetDnDiameter(25);
		//283闭式喷头系统图块126开式喷头系统图块530水喷雾130侧喷下喷
        if(_tcsicmp(_T("TWTSYS(00000283)"), csSysBlk) == 0 || _tcsicmp(_T("TWTSYS(00000126)"), csSysBlk) == 0
			|| _tcsicmp(_T("TWTSYS(00000530)"), csSysBlk) == 0 || _tcsicmp(_T("TWTSYS(00000130)"), csSysBlk) == 0
			|| _tcsicmp(_T("TWTSYS(00000542)"), csSysBlk )== 0) // cet 2013.1.6 modify 水幕系统图块542

			pNewPipe->SetDnDiameter(dPipeDn);
        pNewPipe->EnableDrawLabel(FALSE);
		pNewPipe->SetStartPoint(ptNewS);
		pNewPipe->SetEndPoint(ptNewE);
        pNewPipe->SetHideLevel(1);
        pNewPipe->SetModelType(TPipeSys::kSystem);
		AddToCurrentSpace(pNewPipe, Adesk::kTrue);
		ptStart = ptEnd;
	}
	if(nPipeLength > 0 && (_tcsicmp(_T("TWTSYS(00000283)"), csSysBlk) == 0 || _tcsicmp(_T("TWTSYS(00000126)"), csSysBlk) == 0)) 
		nRotateNewEq = PI;

	// cet 2013.1.5 add 直立型水幕系统图块旋转PI
	if(nPipeLength > 0.0 && (_tcsicmp(csBlkName, _T("$TWTSYS$00000540")) == 0) && (_tcsicmp(_T("TWTSYS(00000542)"), csSysBlk) == 0))
	{
		nRotateNewEq = PI;
	}
  
	pNewEquip->SetAngle(nRotateNewEq + Ucs2Wcs(0.0));// sr 2010-1-28 modify 系统生成支持UCS
    if(_tcsicmp(_T("$TWTSYS$00000147"), csBlkName) == 0){  //排水点
        pNewEquip->SetScale(1);
        pNewEquip->SetYScale(1);
	}


    ptNewS.x = ptStart.x*dX + cos(nRadian)*ptStart.y*dY;
	ptNewS.y = ptStart.z*dZ + sin(nRadian)*ptStart.y*dY;
	ptNewS = Ucs2Wcs(ptNewS);  // sr 2010-1-28 modify 系统生成支持UCS
	
	ptNewE = ptNewS;

    if(csDesName.Find(_T("消火栓")) > -1){  //消火栓
       // pNewEquip->SetNumber(_T("CIRCLE-131"));
		pNewEquip->SetScale(1);
		pNewEquip->SetYScale(1);
		pNewEquip->SetZScale(1);
		pNewEquip->SetAutoScale(TRUE); // cet 2017.6.5 add 随比例变化
		bIsBreak = FALSE;
		//消火栓的插入基点要偏移
		if(fabs(nPipeLength) > 0.001)//上接直接往上偏移131
		{
			if(pNewEquip->IsAutoScale())
				ads_polar(ptNewS, PI/2, 131*pNewEquip->GetPScale()/100, ptNewE); 
			else
				ads_polar(ptNewS, PI/2, 131, ptNewE); 
		}
		else{//平接，要根据接管角度而定
			XPoint ptTmp;
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbEquipment, pEquip);
			if(pEquip){
				int num = pEquip->GetInterfaceNum();
				if(num == 1){
					TPipeInterface face;
					pEquip->GetInterface(0, face);
					AcDbObjectId idPipeTmp = face.m_idPipe; 
					OPENOBJ_BEGIN(idPipeTmp, AcDb::kForRead, TDbPipe, pPipeTmp);
					if(pPipeTmp){
						XPoint p1 = pPipeTmp->StartPoint();
						XPoint p2 = pPipeTmp->EndPoint();
						XPoint p11 = p1;
						XPoint P22 = p2;
						p1.TransformBy(mat); 
						p2.TransformBy(mat); 

						XPoint p3, p4;
						p3.x = p1.x*dX + cos(nRadian)*p1.y*dY;
						p3.y = p1.z*dZ + sin(nRadian)*p1.y*dY;
						p4.x = p2.x*dX + cos(nRadian)*p2.y*dY;
						p4.y = p2.z*dZ + sin(nRadian)*p2.y*dY;
						
						if(p11 == ptInsert)
							ptTmp = p4;
						else if(P22 == ptInsert)
							ptTmp = p3;
					}
					OPENOBJ_END();
				}
			}
			OPENOBJ_END();
			if(!!ptTmp){//消火栓的插入基点要偏移
				double dAng3 = ads_angle(ptTmp, ptNewS);
				ads_polar(ptNewS, dAng3, 131, ptNewE);
			}
		}
	}
	pNewEquip->SetSysBlock(_T(""));
	pNewEquip->SetHidePipe(bIsBreak);
	if(csBlkName != _T("") && _tcsicmp(_T("$TWTSYS$00000131"), csBlkName) == 0)//侧喷时多画一段小横管
	{
		ptNewS = Wcs2Ucs(ptNewS);
		ptNewS.x -= nPipeLength/2;
		ptNewS = Ucs2Wcs(ptNewS);
		ptNewE = ptNewS;
	}
	pNewEquip->SetLocation(ptNewS);
    pNewEquip->SetInsert(ptNewE);



	AddToCurrentSpace(pNewEquip, Adesk::kTrue);
}



//lsd modified 2014-5-9 添加参数nValveType(阀门样式0-斜向 1-正向)
AcDbObjectId PlanValve2Sys(AcDbObjectId id, TDbPipe *pPipe, double nRadian, AcGeMatrix3d mat, AcGeScale3d scale,int nValveType)
{
	XPoint ptStart, ptNewS;		 
	CString csSysBlk, csSysBlk2, csSysBlk3;
    CString csTK, csRecord;
    
	double dX = scale.sx;
	double dY = scale.sy;
	double dZ = scale.sz;
	
	TDbPipeValve *pNewValve = NULL;
    AcDbObjectId idBlk = NULL;
    double nWidth(0);
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeValve, pValve);
	pNewValve = (TDbPipeValve *)pValve->clone();
	
	
    idBlk = pValve->GetBlock2d();
    CString csBlkName = GetBlkNameById(idBlk);
    SplitBlkStr(csBlkName, csTK, csRecord);
    nWidth = pValve->GetWidth();
	csSysBlk = pValve->GetSysBlock();
	ptStart = pValve->GetLocation();
	OPENOBJ_END();
				
	ptStart.TransformBy(mat);
	
	ptStart = Wcs2Ucs(ptStart); // sr 2010-1-28 modify 系统生成支持UCS
	ptNewS.x = ptStart.x*dX + cos(nRadian)*ptStart.y*dY;
	ptNewS.y = ptStart.z*dZ + sin(nRadian)*ptStart.y*dY;
	ptNewS = Ucs2Wcs(ptNewS);  // sr 2010-1-28 modify 系统生成支持UCS
	
	pNewValve->SetLocation(ptNewS);
	XPoint pt1 = pPipe->StartPoint();
	XPoint pt2 = pPipe->EndPoint();
	double ang = ads_angle(pt1, pt2) - Ucs2Wcs(0.0);// sr 2010-1-28 modify 系统生成支持UCS
	pNewValve->SetSysBlock(_T(""));
    int idx = csSysBlk.Find(_T("-"));
    int idx2  = csSysBlk.Find(_T("-"), idx+1);
	
    csSysBlk3 = csSysBlk.Right(8);
    if(idx2 > -1)//平面阀门和系统阀门完全不一样  2005－5－31
        csSysBlk2 = csSysBlk.Mid(idx+1, 8);
	
	
	if(!IsHorAngle(ang) && csSysBlk3 != _T("")){
        if(idx < 0){
            pNewValve->SetBlock2d(idBlk);
            pNewValve->SetWidth(nWidth);
        }
        else if(0 == nValveType){//lsd 2014-5-9 判断阀门样式是否为斜向
            XString xsTmpSys;
            CString csDwb = g_csDwbPath + csTK;
            if(LoadDwbBlock(csDwb, (const TCHAR*)csSysBlk3, xsTmpSys) != RTNORM)
                return NULL;
            double nWidth = GetValveWidth(xsTmpSys);
            pNewValve->SetWidth(nWidth);
            AcDbObjectId recordId = GetBlkIdByName((const TCHAR*)xsTmpSys);
            pNewValve->SetBlock2d(recordId);
        }
	}
    else if(IsHorAngle(ang) && csSysBlk2 != _T("")){
        XString xsTmpSys;
        CString csDwb = g_csDwbPath + csTK;
        if(LoadDwbBlock(csDwb, (const TCHAR*)csSysBlk2, xsTmpSys) != RTNORM)
            return NULL;
        double nWidth = GetValveWidth(xsTmpSys);
        pNewValve->SetWidth(nWidth);
        AcDbObjectId recordId = GetBlkIdByName((const TCHAR*)xsTmpSys);
        pNewValve->SetBlock2d(recordId);
    }
	AcDbObjectId idNewValve = AddToCurrentSpace(pNewValve, Adesk::kTrue);
	return idNewValve;
}


AcDbObjectId PlanLabel2Sys(AcDbObjectId id, TDbPipe *pPipe)
{
    TDbPipeLabel *pNewLabel = NULL;
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeLabel, pLabel);
    pNewLabel = (TDbPipeLabel *)pLabel->clone();
    OPENOBJ_END();
    
    XPoint ptS, ptE, ptMid;
    ptS = pPipe->StartPoint();
    ptE = pPipe->EndPoint();
    XLine line(ptS, ptE, 1);
    line.MidPoint(ptMid);   
    pNewLabel->SetLocation(ptMid);
    AcDbObjectId idNewLabel = AddToCurrentSpace(pNewLabel, Adesk::kTrue);
    return idNewLabel;
    
}

/////////////////////////////////////////////////////// cet 2012-3-2 移植 ///////////////////////////////////////////

//cet 2010.11.22 add 根据管线类型得到标注图层
CString GetDimLayerNameByPipeLayer(const CString &strLayer)
{
	CString strVal = LAY_TEXT;
	if (strLayer.Compare(LAY_PIPE_FEED) == 0 || strLayer.Compare(LAY_PIPE_FEED2) == 0 || strLayer.Compare(LAY_PIPE_FEED3) == 0) //给水 
	{
		strVal = LAY_DIM_FEED;
	} 
	else if (strLayer.Compare(LAY_PIPE_HEADFEED) == 0 || strLayer.Compare(LAY_PIPE_HEADFEED2) == 0 || strLayer.Compare(LAY_PIPE_HEADFEED3) == 0) //热给水 
	{
		strVal = LAY_DIM_HEADFEED;
	} 
	else if (strLayer.Compare(LAY_PIPE_HEADBACK) == 0 || strLayer.Compare(LAY_PIPE_HEADBACK2) == 0 || strLayer.Compare(LAY_PIPE_HEADBACK3) == 0) //热回水
	{
		strVal = LAY_DIM_HEADBACK;
	}
	else if (strLayer.Compare(LAY_PIPE_DIRT) == 0) //污水
	{
		strVal = LAY_DIM_DIRT;
	}
	else if (strLayer.Compare(LAY_PIPE_USELESS) == 0) //废水
	{
		strVal = LAY_DIM_USELESS;
	}
	else if (strLayer.Compare(LAY_PIPE_RAIN) == 0) //雨水
	{
		strVal = LAY_DIM_RAIN;
	}
	else if (strLayer.Compare(LAY_PIPE_USED) == 0 || strLayer.Compare(LAY_PIPE_USED2) == 0 || strLayer.Compare(LAY_PIPE_USED3) == 0) //中水
	{
		strVal = LAY_DIM_USED;
	}
	else if (strLayer.Compare(LAY_PIPE_FIRE) == 0 || strLayer.Compare(LAY_PIPE_FIRE2) == 0 || strLayer.Compare(LAY_PIPE_FIRE3) == 0) //消防
	{
		strVal = LAY_DIM_HYDRANT;
	}
	else if (strLayer.Compare(LAY_PIPE_SPRINKLE) == 0 || strLayer.Compare(LAY_PIPE_SPRINKLE2) == 0 || strLayer.Compare(LAY_PIPE_SPRINKLE3) == 0) //喷淋
	{
		strVal = LAY_DIM_SPRINKLE;
	}
	else if (strLayer.Compare(LAY_PIPE_COAGULATE) == 0) //凝结水
	{
		strVal = LAY_DIM_COAGULATE;
	}
	else if (strLayer.Compare(LAY_PIPE_DRINK) == 0) //直饮水
	{
		strVal = LAY_DIM_DRINK;
	}
	else if (strLayer.Compare(LAY_PIPE_PRESSDIRT) == 0) //压力污水
	{
		strVal = LAY_DIM_PRESSDIRT;
	}
	else if (strLayer.Compare(LAY_PIPE_PRESSUSELESS) == 0) //压力废水
	{
		strVal = LAY_DIM_PRESSUSELESS;
	}
	else if (strLayer.Compare(LAY_PIPE_PRESSRAIN) == 0) //压力雨水
	{
		strVal = LAY_DIM_PRESSRAIN;
	}
	else if (strLayer.Compare(LAY_PIPE_OTHER) == 0) //其他
	{
		strVal = LAY_DIM_OTHER;
	}
	else if (strLayer.Compare(LAY_PIPE_USER1) == 0) //市政给管
	{
		strVal = LAY_DIM_USER1;
	}
	else if (strLayer.Compare(LAY_PIPE_USER2) == 0) //循环给管
	{
		strVal = LAY_DIM_USER2;
	}
	else if (strLayer.Compare(LAY_PIPE_USER3) == 0) //冷却 cet 2012.1.19 add user3-user8
	{
		strVal = LAY_DIM_USER3;
	}
	else if (strLayer.Compare(LAY_PIPE_USER4) == 0) //气体灭火
	{
		strVal = LAY_DIM_USER4;
	}
	else if (strLayer.Compare(LAY_PIPE_USER5) == 0) //蒸汽
	{
		strVal = LAY_DIM_USER5;
	}
	else if (strLayer.Compare(LAY_PIPE_USER6) == 0) //雨淋
	{
		strVal = LAY_DIM_USER6;
	}
	else if (strLayer.Compare(LAY_PIPE_USER7) == 0) //通气
	{
		strVal = LAY_DIM_USER7;
	}
	else if (strLayer.Compare(LAY_PIPE_USER8) == 0) //水景
	{
		strVal = LAY_DIM_USER8;
	}
	return strVal;
}


BOOL GetNearestPoint(const AcGePoint3dArray &points, const XPoint &ptWcs, XPoint &ptNearest)
{
    double nMinDist=0.0;
    int numPoints=points.length();
    if(numPoints<=0)
        return FALSE;
	
    for(int k=0; k<numPoints; k++) {
        XPoint ptCur=points[k];
        ptCur.z=ptWcs.z;
        double nDist=ptWcs.Distance(ptCur);
        if(k>0) {
            if(nDist<nMinDist) {
                nMinDist=nDist;
                ptNearest=ptCur;
            }
        } else {
            nMinDist=nDist;
            ptNearest=ptCur;
        }
    }
    return TRUE;
}




BOOL IsPipeVertical(Entity ent)
{
	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe)
		return pPipe->IsVertical();
	OPENOBJ_END();
	return FALSE;
}

CString GetPipeLayer(Entity entPipe)
{
	CString csLay; 
	OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
		csLay = pPipe->GetLayer();
	}
	OPENOBJ_END();
	return csLay;	
}


CString GetTextLayBySys(TPipeSys::SysType sys)
{
    CString csRet;
    if(sys == TPipeSys::kFeedWater || sys == TPipeSys::kFeedWater2 || sys == TPipeSys::kFeedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_TEXT_FEED;
    else if(sys == TPipeSys::kHeatFeedWater || sys == TPipeSys::kHeatFeedWater2 || sys == TPipeSys::kHeatFeedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_TEXT_HEADFEED;
    else if(sys == TPipeSys::kHeatBackWater || sys == TPipeSys::kHeatBackWater2 || sys == TPipeSys::kHeatBackWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_TEXT_HEADBACK;
    else if(sys == TPipeSys::kDirtWater)
        csRet = LAY_TEXT_DIRT;
    else if(sys == TPipeSys::kUselessWater)
        csRet = LAY_TEXT_USELESS;
    else if(sys == TPipeSys::kRainWater)
        csRet = LAY_TEXT_RAIN;
    else if(sys == TPipeSys::kUsedWater || sys == TPipeSys::kUsedWater2 || sys == TPipeSys::kUsedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_TEXT_USED;
    else if(sys == TPipeSys::kFireFighting || sys == TPipeSys::kFireFighting2 || sys == TPipeSys::kFireFighting3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_TEXT_FIRE;
    else if(sys == TPipeSys::kSprinkle || sys == TPipeSys::kSprinkle2 || sys == TPipeSys::kSprinkle3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_TEXT_SPRINKLE;
    else if(sys == TPipeSys::kCoagulate)
        csRet = LAY_TEXT_COAGULATE;
    else if(sys == TPipeSys::kDrink)
        csRet = LAY_TEXT_DRINK;
    else if(sys == TPipeSys::kPressDirt)
        csRet = LAY_TEXT_PRESSDIRT;
    else if(sys == TPipeSys::kPressUseless)
        csRet = LAY_TEXT_PRESSUSELESS;
    else if(sys == TPipeSys::kPressRain)
        csRet = LAY_TEXT_PRESSRAIN;
    else if(sys == TPipeSys::kCivilFeed)
        csRet = LAY_TEXT_USER1;
    else if(sys == TPipeSys::kCycleFeed)
        csRet = LAY_TEXT_USER2;
    else if(sys == TPipeSys::kOther)
        csRet = LAY_TEXT_OTHER;
	else if (sys == TPipeSys::kUser3)  // cet 2011.12.2 add user3-user8
		csRet = LAY_TEXT_USER3;
	else if (sys == TPipeSys::kUser4)  
		csRet = LAY_TEXT_USER4;
	else if (sys == TPipeSys::kUser5)  
		csRet = LAY_TEXT_USER5;
	else if (sys == TPipeSys::kUser6)  
		csRet = LAY_TEXT_USER6;
	else if (sys == TPipeSys::kUser7)  
		csRet = LAY_TEXT_USER7;
	else if (sys == TPipeSys::kUser8)  
		csRet = LAY_TEXT_USER8;
    return csRet;
}




CString GetPipeTextLayByEnt(Entity ent)
{
	CString csLay;
	TPipeSys::SysType sysType;
	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
		sysType = pPipe->GetSysType();
	}
	OPENOBJ_END();
	csLay = GetTextLayBySys(sysType);
	return csLay;
}


CString GetDimLayBySys(TPipeSys::SysType sys)
{
    CString csRet;
    if(sys == TPipeSys::kFeedWater || sys == TPipeSys::kFeedWater2 || sys == TPipeSys::kFeedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_DIM_FEED;
    else if(sys == TPipeSys::kHeatFeedWater || sys == TPipeSys::kHeatFeedWater2 || sys == TPipeSys::kHeatFeedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_DIM_HEADFEED;
    else if(sys == TPipeSys::kHeatBackWater || sys == TPipeSys::kHeatBackWater2 || sys == TPipeSys::kHeatBackWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_DIM_HEADBACK;
    else if(sys == TPipeSys::kDirtWater)
        csRet = LAY_DIM_DIRT;
    else if(sys == TPipeSys::kUselessWater)
        csRet = LAY_DIM_USELESS;
    else if(sys == TPipeSys::kRainWater)
        csRet = LAY_DIM_RAIN;
    else if(sys == TPipeSys::kUsedWater || sys == TPipeSys::kUsedWater2 || sys == TPipeSys::kUsedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_DIM_USED;
    else if(sys == TPipeSys::kFireFighting || sys == TPipeSys::kFireFighting2 || sys == TPipeSys::kFireFighting3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_DIM_HYDRANT;
    else if(sys == TPipeSys::kSprinkle || sys == TPipeSys::kSprinkle2 || sys == TPipeSys::kSprinkle3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_DIM_SPRINKLE;
    else if(sys == TPipeSys::kCoagulate)
        csRet = LAY_DIM_COAGULATE;
    else if(sys == TPipeSys::kDrink)
        csRet = LAY_DIM_DRINK;
    else if(sys == TPipeSys::kPressDirt)
        csRet = LAY_DIM_PRESSDIRT;
    else if(sys == TPipeSys::kPressUseless)
        csRet = LAY_DIM_PRESSUSELESS;
    else if(sys == TPipeSys::kPressRain)
        csRet = LAY_DIM_PRESSRAIN;
    else if(sys == TPipeSys::kCivilFeed)
        csRet = LAY_DIM_USER1;
    else if(sys == TPipeSys::kCycleFeed)
        csRet = LAY_DIM_USER2;
    else if(sys == TPipeSys::kOther)
        csRet = LAY_DIM_OTHER;
	else if (sys == TPipeSys::kUser3) // cet 2011.12.1 add user3-user8
		csRet = LAY_DIM_USER3;
	else if (sys == TPipeSys::kUser4) 
		csRet = LAY_DIM_USER4;
	else if (sys == TPipeSys::kUser5) 
		csRet = LAY_DIM_USER5;
	else if (sys == TPipeSys::kUser6) 
		csRet = LAY_DIM_USER6;
	else if (sys == TPipeSys::kUser7) 
		csRet = LAY_DIM_USER7;
	else if (sys == TPipeSys::kUser8) 
		csRet = LAY_DIM_USER8;
	
    return csRet;
}


//标注管长，精度受dwg系统变量控制
CString GetDimPipeLen(double dLen)
{
	TDbPsConfig *pConfig = GetDwgPsGlobal(AcDb::kForRead);
	int iPre = 2;
	if (pConfig){
		iPre = pConfig->GetPipeLenPrecision();
		pConfig->close();
	}
	CString csLen;
	CString sHead,sFormat;
	sHead.Format(_T("%d"),iPre);
	sFormat = _T("%.") + sHead + _T("f");
	csLen.Format(sFormat, dLen);
	return csLen;
}




//标注井埋深，精度受dwg系统变量控制
CString GetDimWellDeep(double dDeep)
{
	TDbPsConfig *pConfig = GetDwgPsGlobal(AcDb::kForRead);
	int iPre = 3;
	if (pConfig){
		iPre = pConfig->GetWellDeepPrecision();
		pConfig->close();
	}
	CString csDeep;
	CString sHead,sFormat;
	sHead.Format(_T("%d"),iPre);
	sFormat = _T("%.") + sHead + _T("f");
	csDeep.Format(sFormat, dDeep);
	return csDeep;
}

void UpdateMultDim(Entity ent)
{
    XPoint ptS, ptE;
    GetPipePoint(ent, ptS, ptE);
    if(IsPipeVertical(ent)){
        double nRadius(0);
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            nRadius = pPipe->GetRadius() * pPipe->GetPScale();
        }
        OPENOBJ_END();
        ptS.z = 0;
        ptS.x -= nRadius;
        ptS.y -= nRadius;
        ptE.z = 0;
        ptE.x += nRadius;
        ptE.y += nRadius;
    }
    XPoint ptUcsS, ptUcsE;
    ptUcsS = Wcs2Ucs(ptS);
    ptUcsE = Wcs2Ucs(ptE);
	ptUcsS.z = 0;
	ptUcsE.z = 0;
	//更新引出标注
    RBList rbMaskDim(RTDXF0, _T("ATS_PIPEMULTDIM"), NULL);
	PickSet ssDim(SS_FREE);
	ssDim.Get(_T("C"), ptUcsS, ptUcsE, rbMaskDim);
	long len = ssDim.Length();
	if(len > 0)
		UpdateGraphic(ssDim);
}



void GetAllVertPipeByPt(PickSet &ss, AcDbObjectId id)
{
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
    XPoint ptPipeStart;
    CString csLayer;
    double nDn(0);
	
	XPoint pt;
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe){
        ptPipeStart = pPipe->StartPoint();
        ptPipeStart.z = 0;
		pt = ptPipeStart;
        nDn = pPipe->GetDnDiameter();
        TCHAR *layer;
        layer = pPipe->layer(); 
        csLayer = layer;
        delete [] layer;
    }
    OPENOBJ_END();
	
    XPoint ptUcs = Wcs2Ucs(pt);  
    PickSet ssAll(SS_FREE);
    GetPointPickSet(ptUcs, ssAll, rbMaskPipe, 50);
    if(ssAll.Length() == 0)
        GetPointPickSet(ptUcs, ssAll, rbMaskPipe, 100);
    if(ssAll.Length() == 0)
        GetPointPickSet(ptUcs, ssAll, rbMaskPipe, 200);
    if(ssAll.Length() == 0)
        GetPointPickSet(ptUcs, ssAll, rbMaskPipe, 300);
	
	
    long len = ssAll.Length();
    for(long i=0;i<len;i++){
        Entity ent = ssAll[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe && pPipe->IsVertical()){
            XPoint ptStart = pPipe->StartPoint();
            ptStart.z = 0;
            if(ptStart != ptPipeStart)
                continue;
            double nDn2 = pPipe->GetDnDiameter();
            if(fabs(nDn2 - nDn) > 0.0001)
                continue;
            TCHAR *layer;
            layer = pPipe->layer(); 
            CString csLayer2 = layer;
            delete [] layer;
            if(csLayer2 == csLayer)
                ss += ent;
        }
        OPENOBJ_END();
        
    }
    if(ss.Length() == 0)
        ss += id;
    return;
}

void  RebindVPipeDim(const AcDbObjectId id)
{
	AcGePoint3d ptS,ptE;
	AcDbEntity *pEnt = NULL;
	if (acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead) == Acad::eOk)
	{
		TDbVPipeDim *pDim = TDbVPipeDim::cast(pEnt);
		if (pDim != NULL)
		{
			ptS = pDim->GetStartPt();
			ptE = pDim->GetTurnPt();
		}
		pEnt->close();
	}
	
	RBList rbMak(RTDXF0, _T("ATS_PIPE"),NULL);
	PickSet ssSel(SS_FREE);
	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	vtDir.rotateBy(PI/4,AcGeVector3d::kZAxis);
	XPoint ptET = ptS + vtDir*3.0*DocGetPScale();
	XPoint ptSTmp = ptS - vtDir*3.0*DocGetPScale();
	//	struct resbuf *pointlist = ads_buildlist(RTPOINT, &ptSTmp, RTPOINT, &ptET, NULL); 
	ssSel.Get(_T("C"), Wcs2Ucs(ptSTmp), Wcs2Ucs(ptET),rbMak);
	//	ads_relrb(pointlist);
	
	AcGePoint3d ptST;
	AcDbObjectId idVPipe;
	for (long i = 0; i < ssSel.Length(); ++i)
	{
		OPENOBJ_BEGIN(ssSel[i], AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe && pPipe->IsVertical()) 
		{
			pPipe->getStartPoint(ptST);
			ptST.z = 0.0;
			ptS.z = 0.0;
			if (ptST.distanceTo(ptS) < 1e-3)
			{
				idVPipe = pPipe->objectId();
				break;
			}
		}
        OPENOBJ_END();
	}
	
	if (acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) == Acad::eOk)
	{
		TDbVPipeDim *pDim = TDbVPipeDim::cast(pEnt);
		if (pDim != NULL)
		{
			if (!idVPipe.isNull())
			{
				pDim->SetVPipeId(idVPipe);
			}
			else
			{
				pDim->SetVPipeId(idVPipe);
			}
		}
		pEnt->close();
	}
}


//计算本节点往后共计管线长度
BOOL CalcLstPipeLength(SSearchPipeList *pListAll, SSearchPipeList *pListFront, PickSet &ss)
{
    BOOL ret = TRUE;
    AcDbObjectId id = NULL;
    id = pListAll->m_ID;
    ads_name ent;
    double nCurPipeLength(0);
    acdbGetAdsName(ent, id);
    if(pListAll->m_iType == 2){
        Entity entTmp = ent;
        int iK = _ttoi(ReadXdata(entTmp, _T("SPRINKLER_K")));
        pListAll->m_iSpare = iK;
        if(entTmp.In(&ss))
            pListAll->m_bNeedCale = TRUE;
    }
	else if(pListAll->m_iType == 0){
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            int iDn = (int)(pPipe->GetDnDiameter());
            pListAll->m_iDn = iDn;
            double nGradient = pPipe->GetPipeGradient();
            pListAll->m_nI = nGradient*1000;
            nCurPipeLength = pPipe->Length();
            pListAll->m_nLength = nCurPipeLength;
            if(pPipe->GetDnDiameter() < 0 && !pPipe->IsVertical())
                return FALSE;
        }
        OPENOBJ_END();
    }
    if(pListFront)
        pListAll->m_nLength += pListFront->m_nLength;
	
    long len = pListAll->m_lstNode.Length();
    for(long i=0;i<len;i++){
        SSearchPipeList *pList = pListAll->m_lstNode[i];
        pList->m_pPrevious = pListAll;
        ret = CalcLstPipeLength(pList, pListAll, ss);
        if(!ret)
            return FALSE;
    }
    return ret;
}

//《给水排水管网系统》PAGE 53
//通过差值法计算充满度 h/D  输入参数q/q0 非满流管道流量比
double GetFullByPercentQ(double nPercentQ)
{
    //差值法查表 2003规范 P107页
    double nAc(0);
    if(nPercentQ <= 0.005)
        nAc = GetValBetween2(0, 0.05, 0, 0.005, nPercentQ);
    else if(nPercentQ > 0.005 && nPercentQ <= 0.021)
        nAc = GetValBetween2(0.05, 0.1, 0.005, 0.021, nPercentQ);
    else if(nPercentQ > 0.021 && nPercentQ <= 0.049)
        nAc = GetValBetween2(0.1, 0.15, 0.021, 0.049, nPercentQ);
    else if(nPercentQ > 0.049 && nPercentQ <= 0.088)
        nAc = GetValBetween2(0.15, 0.2, 0.049, 0.088, nPercentQ);
    else if(nPercentQ > 0.088 && nPercentQ <= 0.137)
        nAc = GetValBetween2(0.2, 0.25, 0.088, 0.137, nPercentQ);
    else if(nPercentQ > 0.137 && nPercentQ <= 0.196)
        nAc = GetValBetween2(0.25, 0.3, 0.137, 0.196, nPercentQ);
    else if(nPercentQ > 0.196 && nPercentQ <= 0.263)
        nAc = GetValBetween2(0.3, 0.35, 0.196, 0.263, nPercentQ);
    else if(nPercentQ > 0.263 && nPercentQ <= 0.337)
        nAc = GetValBetween2(0.35, 0.4, 0.263, 0.337, nPercentQ);
    else if(nPercentQ > 0.337 && nPercentQ <= 0.417)
        nAc = GetValBetween2(0.4, 0.45, 0.337, 0.417, nPercentQ);
    else if(nPercentQ > 0.417 && nPercentQ <= 0.5)
        nAc = GetValBetween2(0.45, 0.5, 0.417, 0.5, nPercentQ);
    else if(nPercentQ > 0.5 && nPercentQ <= 0.586)
        nAc = GetValBetween2(0.5, 0.55, 0.5, 0.586, nPercentQ);
    else if(nPercentQ > 0.586 && nPercentQ <= 0.672)
        nAc = GetValBetween2(0.55, 0.6, 0.586, 0.672, nPercentQ);
    else if(nPercentQ > 0.672 && nPercentQ <= 0.756)
        nAc = GetValBetween2(0.6, 0.65, 0.672, 0.756, nPercentQ);
    else if(nPercentQ > 0.756 && nPercentQ <= 0.837)
        nAc = GetValBetween2(0.65, 0.7, 0.756, 0.837, nPercentQ);
    else if(nPercentQ > 0.837 && nPercentQ <= 0.912)
        nAc = GetValBetween2(0.7, 0.75, 0.837, 0.912, nPercentQ);
    else if(nPercentQ > 0.912 && nPercentQ <= 0.977)
        nAc = GetValBetween2(0.75, 0.8, 0.912, 0.977, nPercentQ);
    else if(nPercentQ > 0.977 && nPercentQ <= 1.03)
        nAc = GetValBetween2(0.8, 0.85, 0.977, 1.03, nPercentQ);
    else if(nPercentQ > 1.03 && nPercentQ <= 1.066)
        nAc = GetValBetween2(0.85, 0.9, 1.03, 1.066, nPercentQ);
    else if(nPercentQ > 1.066 && nPercentQ <= 1.075)
        nAc = GetValBetween2(0.9, 0.95, 1.066, 1.075, nPercentQ);
    else if(nPercentQ > 1.075)
        nAc = GetValBetween2(0.95, 1, 1.075, 2.0, nPercentQ);
    else if(fabs(nPercentQ -1) < 0.001)
        nAc = 1;
	
    return nAc;
}

//返回用户选择的最远井所在链表的位置
SSearchPipeList *GetPipeNodeByName(SSearchPipeList *pListAll, CString csName, SSearchPipeList *pNode)
{
    AcDbObjectId id = NULL;
    id = pListAll->m_ID;
    if(pListAll->m_iType == 0){
        if(pListAll->m_csName == csName)
            return pListAll;
    }
    long len = pListAll->m_lstNode.Length();
    for(long i=0;i<len;i++){
        SSearchPipeList *pList = pListAll->m_lstNode[i];
        pNode = GetPipeNodeByName(pList, csName, pNode);
    }
    return pNode;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////

 std::map<CString,BOOL> g_mapShowVPipeDimDn; // 立管标注样式4，立管是否显示管径
  
 void InitVPipeDimDnShow()
 {
 	g_mapShowVPipeDimDn.clear();
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FEED,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADFEED,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADBACK,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_DIRT,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USELESS,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_RAIN,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USED,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FIRE,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_SPRINKLE,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_COAGULATE,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_DRINK,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_PRESSDIRT,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_PRESSUSELESS,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_PRESSRAIN,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_OTHER,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER1,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER2,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FEED2,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FEED3,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADFEED2,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADFEED3,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADBACK2,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADBACK3,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FIRE2,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FIRE3,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_SPRINKLE2,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_SPRINKLE3,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USED2,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USED3,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER3,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER4,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER5,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER6,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER7,TRUE));
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER8,TRUE));
 }
 
 BOOL IsShowVPipeDimDn(const CString &sPipeLayer)
 {
 	std::map<CString,BOOL>::iterator it;
 	it = g_mapShowVPipeDimDn.find(sPipeLayer);
 	if (it != g_mapShowVPipeDimDn.end())
 	{
 		return it->second;
 	}
 	return FALSE;
 }
 
 BOOL SetShowVPipeDimDn(const CString &sPipeLayer, BOOL bShow)
 {
 	std::map<CString,BOOL>::iterator it;
 	it = g_mapShowVPipeDimDn.find(sPipeLayer);
 	if (it != g_mapShowVPipeDimDn.end())
 	{
 		it->second = bShow;
 		return TRUE;
 	}
 	return FALSE;
 }
 
 void ReadVPipeDimDnShow()
 {
 	g_mapShowVPipeDimDn.clear();
 	CRegProperty regProp(GetRegLocation(), _T("TWTConfig"));    
     regProp.SetTopRootKey(HKEY_CURRENT_USER);
 	bool bShow = false;
 	if (!regProp.GetValue(_T("VPipeDimDn1"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FEED,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn2"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADFEED,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn3"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADBACK,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn4"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_DIRT,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn5"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USELESS,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn6"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_RAIN,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn7"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USED,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn8"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FIRE,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn9"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_SPRINKLE,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn10"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_COAGULATE,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn11"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_DRINK,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn12"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_PRESSDIRT,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn13"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_PRESSUSELESS,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn14"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_PRESSRAIN,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn15"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_OTHER,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn16"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER1,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn17"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER2,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn18"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FEED2,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn19"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FEED3,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn20"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADFEED2,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn21"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADFEED3,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn22"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADBACK2,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn23"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_HEADBACK3,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn24"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FIRE2,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn25"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_FIRE3,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn26"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_SPRINKLE2,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn27"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_SPRINKLE3,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn28"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USED2,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn29"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USED3,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn30"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER3,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn31"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER4,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn32"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER5,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn33"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER6,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn34"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER7,bShow));
 	if (!regProp.GetValue(_T("VPipeDimDn35"), bShow))
 		bShow = true;
 	g_mapShowVPipeDimDn.insert(std::make_pair(LAY_VPIPE_USER8,bShow));
 	regProp.GetValue(_T("nAlignTypeForVPipeDim4"), g_nAlignTypeForVPipeDim4);
 }


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//更新管线标高标注 2013-4-27 CET ADD
void UpdateElevationDim(PickSet &ssPipe)
{
	RBList rbMark(RTDXF0, _T("ATS_ELEVATION"), NULL);
	PickSet ssDim;
	ssDim.Get(_T("X"), NULL, NULL, rbMark);
	int nDimNum = ssDim.Length();
	if (nDimNum == 0)
	{
		return;
	}

	std::vector<std::pair<Entity, XPoint> > vecDim;
	for (long j = 0; j < nDimNum; ++j)
	{
		OPENOBJ_BEGIN(ssDim[j], AcDb::kForRead, TDbSymbElevation, pDim);
		if (pDim != NULL)
		{
			vecDim.push_back(std::make_pair(ssDim[j], pDim->GetLocation()));
		}
		OPENOBJ_END();
	}

	std::vector<std::pair<Entity, XPoint> >::iterator it, itEnd = vecDim.end();
	long nLen = ssPipe.Length();
	AcGePoint3d ptS, ptE, ptLoc;
	AcGeTol tol;
	tol.setEqualPoint(0.001);
	double dMeter = 1;
	if (!DocGetMeterUnitDraw())
	{
		tol.setEqualPoint(1);
		dMeter = 0.001;
	}
	AcGeLine3d line1;
	CString sText;
	for (long i = 0; i < nLen; ++i)
	{
		OPENOBJ_BEGIN(ssPipe[i], AcDb::kForRead, TDbPipe, pPipe);
		if (pPipe != NULL)
		{
			if (pPipe->IsVertical())
			{
				continue;
			}
			ptS = pPipe->StartPoint();
			ptE = pPipe->EndPoint();
			ptS.z = 0.0;
			ptE.z = 0.0;
			line1.set(ptS, ptE);
			for (it = vecDim.begin(); it != itEnd; ++it)
			{
				ptLoc = it->second;
				ptLoc.z = 0.0;
				
				// 判断点是否在线上 zxl2013.10.15 modify
				//if (!line1.isOn(ptLoc, tol))
				AcGePointOnCurve3d ptOnCrv;
				line1.getClosestPointTo(ptLoc, ptOnCrv, tol);
				if (ptLoc.distanceTo(ptS) + ptLoc.distanceTo(ptE) - ptS.distanceTo(ptE) > 0.001)
				{
					continue;
				}

				double dDist = ptLoc.distanceTo(ptS);
				double dLen = ptS.distanceTo(ptE);
				double dEle = (pPipe->EndPoint().z - pPipe->StartPoint().z) * ( dDist / dLen) + pPipe->StartPoint().z;

				OPENOBJ_BEGIN(it->first, AcDb::kForWrite, TDbSymbElevation, pDim);
				if (pDim != NULL)
				{
				    sText.Format(_T("%.3f"), dEle * dMeter);
					pDim->SetText(sText);
				}
				OPENOBJ_END();
			}		     
		}
		OPENOBJ_END();
	}
}

void UpdateElevationDim(Entity &entPipe)
{
	PickSet ss(SS_FREE);
	ss += entPipe;
	UpdateElevationDim(ss);
}

void UpdateElevationDim(const AcDbObjectId &idPipe)
{
	ads_name name;
	acdbGetAdsName(name, idPipe);
	Entity ent(name);
	UpdateElevationDim(ent);
}