#include "stdafx.h"
#include "resource.h"
#include "KTAxisCmdGroup.h"
#include "KTLineAxisGridDlg.h"
#include "KTLineAxisCreator.h"
#include "KTAxisGridJig.h"
#include "KTTempTol.h"
#include "KTCADUtilityEx.h"
#include "KTCADSysVar.h"
#include "KTAxisDimLabelDlg.h"
#include "KTSetting.h"
#include "KTCadUtility.h"
#include "KTModelLayoutXData.h"
#include <vector>
#include <algorithm>
#include "EarThwormDef.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

static void FreeBuffer(int n, AcDbVoidPtrArray &arEntPtrs)
{
	AcDbEntity *pEnt = NULL;
	while (arEntPtrs.length() > n)
	{
		pEnt = (AcDbEntity *)arEntPtrs.last();
		pEnt->erase();
		pEnt->close();
		DELETE_PTR(pEnt);
		arEntPtrs.removeLast();
	}
}

KTAxisCmdGroup::KTAxisCmdGroup()
{
}

KTAxisCmdGroup::~KTAxisCmdGroup()
{

}

int KTAxisCmdGroup::MakeLineAxis()
{
	CAcModuleResourceOverride myResources;
	
	KTLineAxisGridDlg wndAxisGridDlg;
	int nRes = wndAxisGridDlg.DoModal();
	if (nRes == IDOK)
	{
		CString sLay,sNameFr;
		AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_AXIS"));
		KTSetting::GetLayerName(_T("LAY_AXIS"),sLay,sNameFr);

		KTLineAxisCreator creator;
		creator.SetStartAngle(wndAxisGridDlg.m_dAngle);
		for (int i = 0; i < 4; i++)
		{
			creator.SetArrayData(i, wndAxisGridDlg.m_arSpaceText[i]);
		}

		creator.Create();
		AcDbVoidPtrArray arEntPtrs;
		creator.GetAxisEntities(arEntPtrs);

		int iIndex = arEntPtrs.length();
		if (iIndex <= 0)
			return FALSE;
		AcDbEntity * pEnt = NULL;

		while ((--iIndex) >= 0)
		{
			pEnt = (AcDbEntity *)arEntPtrs.at(iIndex);
			pEnt->setLayer(sLay);
		}

		iIndex = arEntPtrs.length();
		KTAxisGridJig axisGridJig;
		axisGridJig.SetEntitiesPtrs(arEntPtrs);
		if (axisGridJig.Doit())
		{
			while ((--iIndex) >= 0)
			{
				pEnt = (AcDbEntity *)arEntPtrs.at(iIndex);
				ASSERT(NULL != pEnt);
				pEnt->setLayer(sLay);
				
				CKTCadUtility::AddToBlockTableRecord(pEnt);
				pEnt->close();
			}
		}
		else
		{
			// jig不成功, 删除创建的对象，释放内存
			while ((--iIndex) >= 0)
			{
				pEnt = (AcDbEntity*)arEntPtrs.at(iIndex);
				ASSERT(NULL != pEnt);
				delete pEnt;
			}
		}
	}
	return 0;
}

static void GetFencePickSet(AcDbObjectIdArray& ids, AcDbObjectId& cv, struct resbuf* pResbuf)
{
	AcDbCurve* pCurve = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity((AcDbEntity*&)pCurve,cv,AcDb::kForRead))
	{
		AcGePoint3d pt1,pt2;
		pCurve->getStartPoint(pt1);
		pCurve->getEndPoint(pt2);

		ads_point pt11,pt22;
		pt11[X] = pt1.x;
		pt11[Y] = pt1.y;
		pt11[Z] = pt1.z;
		pt22[X] = pt2.x;
		pt22[Y] = pt2.y;
		pt22[Z] = pt2.z;
		acdbWcs2Ucs(pt11,pt11,false);
		acdbWcs2Ucs(pt22,pt22,false);
		pCurve->close();

		CKTCadUtility::ZoomInCurrentView(pt1,pt2);

		ads_name ss,ent;
		acedSSGet(_T("F"),NULL,NULL,pResbuf,ss);

		AcDbObjectId id;
		Adesk::Int32 lLen = 0;
		acedSSLength(ss,&lLen);
		for (int i = 0;i < lLen;i++)
		{
			acedSSName(ss,i,ent);
			acdbGetObjectId(id,ent);
			ids.append(id);
		}
		acedSSFree(ss);
	}
}

int KTAxisCmdGroup::LineAxisDim()
{
	AecDbObjXDataMap xDataMap;
	if (!KTModelLayoutXData::ReadModelXData(KT_PIPEINIT,xDataMap))
	{
		acedAlert(_T("\n系统未初始化!"));
		return 0;
	}

	CAcModuleResourceOverride myResources;

	KTTempTol TempTol(1e-3);

	ads_name entCross, entFirst, entFinal;
	ads_point ptPick1, ptPick2;

	CString sText;
	sText = _T("\n请选择起始轴线<退出>:");

	CString sLayer,sTemp;
	KTSetting::InitLayer(_T("LAY_AXIS"));
	KTSetting::GetLayerName(_T("LAY_AXIS"),sLayer,sTemp);

	struct resbuf* pResbuf = acutBuildList(RTDXF0, _T("LINE"), 8, sLayer, 0); ;
	if (RTNORM != CKTCadUtility::SelectEntity1(sText,entCross,pResbuf,ptPick1))
	{
		acutRelRb(pResbuf);
		return 0;
	}

	sText = _T("\n请选择终止轴线<退出>:");
	int iRet = CKTCadUtility::SelectEntity1(sText,entFinal,pResbuf,ptPick2);
	if (iRet != RTNORM)
	{
		acutRelRb(pResbuf);
		return 0;
	}
	
	acdbUcs2Wcs(ptPick1,ptPick1,false);
	acdbUcs2Wcs(ptPick2,ptPick2,false);

   	// 作为横断轴线, 取出与横断线相交的起始和终止轴线
	BOOL bCross = (iRet == RTNONE);
	if (bCross)
	{
		if (!KTCADUtilityEx::FindMaxBoundAxis(entCross, entFirst, entFinal, ptPick1, ptPick2))
		{
			acutRelRb(pResbuf);
			return 0;
		}
	}
	else
	{
		ads_name_set(entCross,entFirst);		
	}

	// 单轴标注
	if(ads_name_equal(entFirst,entFinal))
	{
		OnDimSingleAxisCurve(asPnt3d(ptPick1), entFirst, TRUE);
		acutRelRb(pResbuf);
		return 0;
	}

	int iType = KTCADUtilityEx::GetAxisRelationShip(entFirst, entFinal);

	AcDbObjectId idFir,idFin;
	acdbGetObjectId(idFir,entFirst);
	acdbGetObjectId(idFin,entFinal);

	if (idFir == idFin)
	{
		acutPrintf(_T("\n选择的轴线是同一条轴线!无法轴网标注"));
		return 0;
	}

	AcDbObjectIdArray ids;
	GetPalsFrom2Curve(ids,idFir, idFin);

	ads_name ent;
	for (int i = 0;i < ids.length();i++)
	{
		acdbGetAdsName(ent,ids.at(i));
		acedRedraw(ent,3);
	}
	acedUpdateDisplay();
	for (i = 0;i < ids.length();i++)
	{
		acdbGetAdsName(ent,ids.at(i));
		acedRedraw(ent,4);
	}
	
	AcDbObjectId identCur, identOth;
	BOOL bOutSide = FALSE;
	BOOL bRadiator = FALSE;
	BOOL bCirAngular = FALSE;
	m_sStartLabel = _T("1");

	switch (iType)
	{
	case 1:	// 平行线轴网
		KTCADUtilityEx::SortParallelAxisLine(ids);

		OPENOBJ_BEGIN(idFir, AcDb::kForRead, AcDbLine, pLine);
		if (pLine != NULL)
		{
			double dAngle = acutAngle( asDblArray(CKTCadUtility::Wcs2Ucs(pLine->startPoint())),
									   asDblArray(CKTCadUtility::Wcs2Ucs(pLine->endPoint())));

			if(dAngle < 0.25 * PI || dAngle > 1.75 * PI || (dAngle > 0.75 * PI && dAngle < 1.25 * PI))
				m_sStartLabel = _T("A");
		}
		OPENOBJ_END();

		m_bUpside = KTCADUtilityEx::GetParallelAxisLineInitParam(asPnt3d(ptPick1), ids.first(),ids.last(),
			bCross, m_ptCurStart, m_ptCurEnd, m_ptOthStart, m_ptOthEnd, m_vecCur, m_vecOth);
		//求边界曲线
		{
			AcDbObjectIdArray idsFirs,idsFinal;
			GetFencePickSet(idsFirs, idFir, pResbuf);
			GetFencePickSet(idsFinal, idFin, pResbuf);

			idsFirs.remove(idFir);
			idsFinal.remove(idFin);

			//
			typedef KTCADUtilityEx::CSortPair<double, AcDbObjectId, KTCADUtilityEx::DoubleCompare> CEntSortPair;
			AcArray<CEntSortPair> arEntSort;
			CEntSortPair data;
			//
			AcDbXline xline;
			xline.setBasePoint(m_ptCurStart);
			xline.setUnitDir(m_ptOthStart - m_ptCurStart);
			AcGePoint3d ptNear;
			AcGePoint3dArray arpt;
			long lPos = idsFirs.length();
			int nF = -1;
			while ((--lPos) >=0)
			{
				if (!idsFinal.find(idsFirs[lPos],nF))
					continue;

				arpt.setLogicalLength(0);
				OPENOBJ_BEGIN(idsFirs[lPos], AcDb::kForRead, AcDbCurve, pCurve);
				if (pCurve != NULL && Acad::eOk == xline.intersectWith(pCurve, AcDb::kExtendArg, arpt) &&
					!arpt.isEmpty())
				{
					xline.getClosestPointTo(arpt[0], ptNear);
					xline.getParamAtPoint(ptNear, data.compare);
					data.value = idsFirs[lPos];
					arEntSort.append(data);
				}
				OPENOBJ_END();
			}
			
			lPos = arEntSort.length();
			if (lPos > 1)
			{
				QuickSort(arEntSort.asArrayPtr(), lPos);
				xline.getClosestPointTo(m_ptCurStart, ptNear);
				xline.getParamAtPoint(ptNear, data.compare);
				if (fabs(arEntSort[0].compare - data.compare) < fabs(arEntSort[lPos-1].compare - data.compare))
				{
					identCur = arEntSort[0].value;
					identOth = arEntSort[lPos-1].value;
				}
				else
				{
					identCur = arEntSort[lPos-1].value;
					identOth = arEntSort[0].value;
				}
			}
		}
		break;
	default:
		{
			acutRelRb(pResbuf);
			return 0;
		}
	}

	for (i = 0;i < ids.length();i++)
	{
		acdbGetAdsName(ent,ids.at(i));
		acedRedraw(ent,3);
	}
	acedUpdateDisplay();
	
	KTAxisDimLabelDlg dlg;
	dlg.m_bPrevLabel = FALSE;
	dlg.m_sStartLabel = m_sStartLabel;
	dlg.m_iDimType = 2;
	dlg.m_iLabelType = 2;

	if (dlg.DoModal() != IDOK)
	{
		for (i = 0;i < ids.length();i++)
		{
			acdbGetAdsName(ent,ids.at(i));
			acedRedraw(ent,4);
		}
		acutRelRb(pResbuf);
		return 0;
	}
	for (i = 0;i < ids.length();i++)
	{
		acdbGetAdsName(ent,ids.at(i));
		acedRedraw(ent,4);
	}

	m_iLabelType = dlg.m_iLabelType;
	m_iDimType = dlg.m_iDimType;
	m_sStartLabel = dlg.m_sStartLabel;

	acutRelRb(pResbuf);
	if (dlg.m_bPrevLabel)
	{
		AcGePoint3d ptPrev;
		sText = _T("\n点取前接轴号<退出>:");
		ads_name entPrev;

		ads_point ptT;
		pResbuf = acutBuildList(RTDXF0, _T("INSERT"), 8, sLayer, 2, _T("_axiso*"), 0);
		if (RTNORM != CKTCadUtility::SelectEntity1(sText,entPrev,pResbuf,ptT))
		{
			acutRelRb(pResbuf);
			return 0;
		}
		
		acutRelRb(pResbuf);
		AcDbObjectId idPrev;
		acdbGetObjectId(idPrev,entPrev);

		OPENOBJ_BEGIN(idPrev, AcDb::kForRead, AcDbBlockReference, pBlkRef);
			if (pBlkRef == NULL)
			{
				return 0;
			}

			AcDbObjectIterator* pIT = pBlkRef->attributeIterator();
			if (pIT == NULL)
				return 0;
			pIT->start();
			AcDbObjectId idAttr = pIT->objectId();
			delete pIT;
			if (!idAttr.isValid())
				return 0;
			AcDbAttribute* pAttr = NULL;
			pBlkRef->openAttribute(pAttr, idAttr, AcDb::kForRead);
			if (pAttr == NULL)
				return 0;
			LPTSTR pszText = pAttr->textString();
			m_sStartLabel = pszText;
			acutDelString(pszText);
			pAttr->close();

			ptPrev = pBlkRef->position();
		OPENOBJ_END();
	
		if(iType == 1)
		{
			if(!(m_ptCurStart-m_ptCurEnd).isParallelTo(CKTCadUtility::GetUcsYAxis()) )
			{
				m_bUpside = ptPick1[X] < ptPrev[X];
			}
			else
			{
				m_bUpside = ptPick1[Y] < ptPrev[Y];
			}

			if(m_bUpside)
			{
				AcGePoint3d pt;
				pt = m_ptCurStart;
				m_ptCurStart = m_ptCurEnd;
				m_ptCurEnd = pt;
				
				pt = m_ptOthStart;
				m_ptOthStart = m_ptOthEnd;
				m_ptOthEnd = pt;
			}
		}
		m_sStartLabel = KTCADUtilityEx::GetNewAxisLabel(m_sStartLabel, TRUE);
	}

	ads_name entCur, entOth;
	acdbGetAdsName(entCur,identCur);
	acdbGetAdsName(entOth,identOth);
	
	OnDimParallelAxisLine(ids, entCur, entOth);

	return 1;
}

int KTAxisCmdGroup::SingleAxisDim()
{
	AecDbObjXDataMap xDataMap;
	if (!KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap))
	{
		acedAlert(_T("\n系统未初始化!"));
		return 0;
	}

	CAcModuleResourceOverride myResources;

	KTTempTol TempTol(1e-3);

	ads_name entCross, entFirst, entFinal;
	ads_point ptPick1, ptPick2;

	CString sText;
	sText = _T("\n请选择轴线<退出>:");

	CString sLayer, sTemp;
	KTSetting::InitLayer(_T("LAY_AXIS"));
	KTSetting::GetLayerName(_T("LAY_AXIS"), sLayer, sTemp);

	struct resbuf *pResbuf = acutBuildList(RTDXF0, _T("LINE"), 8, sLayer, 0); ;
	if (RTNORM != CKTCadUtility::SelectEntity1(sText, entCross, pResbuf, ptPick1))
	{
		acutRelRb(pResbuf);
		return 0;
	}

	acdbUcs2Wcs(ptPick1, ptPick1, false);

	ads_name_set(entCross, entFirst);
	
	OnDimSingleAxisCurve(asPnt3d(ptPick1), entFirst, TRUE);
	acutRelRb(pResbuf);
	return 1;
}

BOOL KTAxisCmdGroup::IsLineIsAxisLine(AcDbLine* pLn, AcDbVoidPtrArray& arEntPtrs, AcGePoint3d &ptOn, AcGePoint3d& ptBase)
{
	AcGePoint3d ptS = pLn->startPoint();
	AcGePoint3d ptE = pLn->endPoint();

	AcDbEntity *pEnt = NULL;
	for (int i = 0;i < arEntPtrs.length();i++)
	{
		pEnt = (AcDbEntity *)arEntPtrs.at(i);
		AcDbCircle *pCir = AcDbCircle::cast(pEnt);
		if (pCir != NULL)
		{
			if (fabs(ptS.distanceTo(pCir->center()) - pCir->radius()) < 1.e-1)
			{
				ptOn = ptS;
				ptBase = ptE;
				return TRUE;
			}

			if (fabs(ptE.distanceTo(pCir->center()) - pCir->radius()) < 1.e-1)
			{
				ptOn = ptE;
				ptBase = ptS;
				return TRUE;
			}
		}
	}
	return FALSE;
}

BOOL KTAxisCmdGroup::GetAxisDimBasePoint(AcDbObjectId& id, AcDbObjectId& idLn,AcGePoint3d& ptOn,AcGePoint3d& ptBase)
{
	AcDbVoidPtrArray arEntPtrs;
	AcDbExtents ext;
	AcDbEntity *pEnt = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
	{
		pEnt->getGeomExtents(ext);
		pEnt->explode(arEntPtrs);
		pEnt->close();
	}
	pEnt = NULL;

	//得到参考位置点
	CString sLayer, sTemp;
	KTSetting::InitLayer(_T("LAY_DIMAX"));
	KTSetting::GetLayerName(_T("LAY_DIMAX"), sLayer, sTemp);

	AcGePoint3d ptMin = ext.minPoint();
	AcGePoint3d ptMax = ext.maxPoint();
	ptMin.z = 0; ptMax.z = 0;
	AcGeVector3d vtM = ptMax - ptMin;
	vtM.normalize(); vtM *= 1.2; ptMin -= vtM; ptMax += vtM;
	ads_point ptbox1, ptBox2;

	acdbWcs2Ucs(asDblArray(ptMin), ptbox1, false);
	acdbWcs2Ucs(asDblArray(ptMax), ptBox2, false);

	struct resbuf *pResbuf = acutBuildList(RTDXF0, _T("LINE"), 8, sLayer, 0);
	ads_name ss,ent;
	acedSSGet(_T("C"), ptbox1, ptBox2, pResbuf, ss);
	acutRelRb(pResbuf);

	Adesk::Int32 nLen = 0;
	acedSSLength(ss, &nLen);

	BOOL bSuccess = FALSE;
	AcDbObjectId idT;
	for (Adesk::Int32 i = 0;i < nLen;i++)
	{
		acedSSName(ss, i, ent);
		acdbGetObjectId(idT, ent);

		if (Acad::eOk == acdbOpenAcDbEntity(pEnt, idT, AcDb::kForRead))
		{
			AcDbLine *pLn = AcDbLine::cast(pEnt);
			if (pLn != NULL)
			{
				//判断直线端点落在轴号上
				if ( IsLineIsAxisLine(pLn, arEntPtrs,ptOn,ptBase) )
				{
					idLn = idT;
					bSuccess = TRUE;
					pEnt->close();
					break;
				}
			}
			pEnt->close();
		}
	}
	acedSSFree(ss);
	FreeBuffer(0,arEntPtrs);

	return bSuccess;
}

BOOL KTAxisCmdGroup::GetDimLable(AcDbObjectId&idPrev, TCHAR* pszDim)
{
	BOOL bGet = FALSE;
	OPENOBJ_BEGIN(idPrev, AcDb::kForRead, AcDbBlockReference, pBlkRef);
	if (pBlkRef == NULL)
	{
		return bGet;
	}
	
	AcDbObjectIterator *pIT = pBlkRef->attributeIterator();
	if (pIT == NULL)
		return 0;
	pIT->start();
	AcDbObjectId idAttr = pIT->objectId();
	delete pIT;
	if (!idAttr.isValid())
		return 0;
	AcDbAttribute *pAttr = NULL;
	pBlkRef->openAttribute(pAttr, idAttr, AcDb::kForRead);
	if (pAttr == NULL)
		return 0;
	LPTSTR pszText = pAttr->textString();
	_tcscpy(pszDim,pszText);
	acutDelString(pszText);
	bGet = TRUE;
	pAttr->close();

	OPENOBJ_END();
	return bGet;
}

bool UnguardedSortAdimbs(ADimBs& abs1, ADimBs& abs2)
{
	if (_ttoi(abs1.szDim) < _ttoi(abs2.szDim))
		return true;
	return false;
}

void KTAxisCmdGroup::SortADimBs(AcArray<ADimBs> &arDb1)
{
	std::vector< ADimBs> vtDb1;
	for (int i = 0;i < arDb1.length();i++)
	{
		ADimBs &abs = arDb1.at(i);
		vtDb1.push_back(abs);
	}
	std::sort(vtDb1.begin(),vtDb1.end(), UnguardedSortAdimbs);
	arDb1.removeAll();

	for (int i = 0;i < vtDb1.size();i++)
	{
		arDb1.append(vtDb1.at(i));
	}
}

static bool IsStepOntheLine(ADimBs &abs1, ADimBs &abs2)
{
	AcGeLine3d ln(abs1.ptOn, abs1.ptBase);
	AcGePoint3d pt2 = ln.closestPointTo(abs2.ptOn);
	
	//共线,并且同轴号
	if ( pt2.distanceTo(abs2.ptOn) < 1.e-2 &&
		_tcscmp(abs1.szDim,abs2.szDim) == 0)
	{
		return true;
	}
	return false;
}

//对应 arDb1 的 arDb2
void KTAxisCmdGroup::PairAdimBs(AcArray<ADimBs> &arDb1, AcArray<ADimBs> &arDb2)
{
	AcArray<ADimBs> arDb22;
	for (int i = 0; i < arDb1.length(); i++)
	{
		ADimBs &abs = arDb1.at(i);
		//acutPrintf(_T("\nabs1.dim = %s"),abs.szDim);

		for (int j = 0;j < arDb2.length();j++)
		{
			ADimBs &abs2 = arDb2.at(j);

			//共线
			if (IsStepOntheLine(abs,abs2))
			{
				//acutPrintf(_T("\nabs2.dim = %s"), abs2.szDim);
				arDb22.append(abs2);
			}
		}
	}
	arDb2.removeAll();
	arDb2.append(arDb22);
}

BOOL KTAxisCmdGroup::Get2SideAxisDim(AcArray<ADimBs> &arDb1, AcArray<ADimBs> &arDb2, AcGePoint3d &ptOn, AcGePoint3d &ptBase)
{
	CString sLayEn, sLayCn;
	KTSetting::InitLayer(_T("LAY_DIMAX"));
	KTSetting::GetLayerName(_T("LAY_DIMAX"), sLayEn, sLayCn);
	KTCADSysVar<LPCTSTR, TRUE> clayer(_T("CLAYER"), sLayEn);

	struct resbuf *pResbuf = acutBuildList(RTDXF0, _T("INSERT"), 8, sLayEn, 0); ;

	ads_name ss, ent;
	acedSSGet(_T("X"), NULL, NULL, pResbuf, ss);

	AcDbObjectIdArray arId;
	Adesk::Int32 nLen = 0;
	acedSSLength(ss, &nLen);
	AcDbObjectId id2,idLn;
	for (Adesk::Int32 i = 0; i < nLen; i++)
	{
		acedSSName(ss, i, ent);
		acdbGetObjectId(id2, ent);
		arId.append(id2);
	}
	acedSSFree(ss);
	acutRelRb(pResbuf);

	AcGeLineSeg3d lnSeg0(ptOn,ptBase);
	AcGeLine3d ln3d;
	AcGeVector3d vtL,vtL0;
	vtL0 = ptBase - ptOn;

	ADimBs adbs;
	AcGePoint3d ptOn1, ptBase1,ptM, ptInt;
	for (int i = 0;i < arId.length();i++)
	{
		id2 = arId.at(i);
		if (GetAxisDimBasePoint(id2,idLn, ptOn1, ptBase1))
		{
			adbs.id = id2;
			adbs.idLn = idLn;
			adbs.ptBase = ptBase1;
			adbs.ptOn = ptOn1;
			GetDimLable(id2, adbs.szDim);

			//分集
			Midpoint(ptOn1, ptBase1, ptM);
			vtL = ptBase1 - ptOn1;
			vtL.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);

			ln3d.set(ptM, vtL);

			if (ln3d.intersectWith(lnSeg0, ptInt))
			{
				arDb1.append(adbs);
			}
			else
			{
				vtL = ptBase1 - ptOn1;
				if (vtL.isParallelTo(vtL0))//平行
				{
					arDb2.append(adbs);
				}
			}
		}
	}

	SortADimBs(arDb1);

	//对应 arDb1 的 arDb2
	PairAdimBs(arDb1, arDb2);

	return TRUE;
}

BOOL KTAxisCmdGroup::InsertAxisLable(ADimBs &adbs1, AcGeMatrix3d &vtM)
{
	AcDbEntity *pEnt1 = NULL, *pEnt2 = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, adbs1.id, AcDb::kForRead))
	{
		AcDbEntity *pEnt11 = (AcDbEntity *)pEnt1->clone();
		if (pEnt11 != NULL)
		{
			pEnt11->transformBy(vtM);

			AcDbBlockReference *pBlkRef = AcDbBlockReference::cast(pEnt11);

			AcDbObjectIterator *pIT = pBlkRef->attributeIterator();
			if (pIT == NULL)
				return 0;

			for (pIT->start(); !pIT->done(); pIT->step())
			{
				AcDbEntity *pAttrEnt = pIT->entity();
				AcDbAttribute *pAttr = AcDbAttribute::cast(pAttrEnt);
				if (pAttr != NULL)
				{
					LPTSTR pszText = pAttr->textString();

					CString sTxt;
					sTxt.Format(_T("%d"), _ttoi(pszText) + 1);
					pAttr->setTextString(sTxt);

					acutDelString(pszText);

					pAttrEnt->close();

					break;
				}
				pAttrEnt->close();
			}

			delete pIT;

			AcGePoint3d ptBase = adbs1.ptBase;
			ptBase.transformBy(vtM);

			AcGePoint3d ptOn = adbs1.ptOn;
			ptOn.transformBy(vtM);

			AcDbLine *pLine = new AcDbLine(ptOn, ptBase);
			pLine->setLayer(pEnt1->layerId());

			AcDbObjectId idTmp;
			CKTCadUtility::AddToBlockTableRecord(idTmp, pLine);
			pLine->close();
			CKTCadUtility::AddToBlockTableRecord(idTmp, pBlkRef);
			pBlkRef->close();
		}
		pEnt1->close();
	}
	return TRUE;
}

BOOL KTAxisCmdGroup::EraseAxisLable(ADimBs &adbs1)
{
	AcDbEntity *pEnt1 = NULL, *pEnt2 = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, adbs1.id, AcDb::kForWrite))
	{
		pEnt1->erase();
		pEnt1->close();
	}

	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, adbs1.idLn, AcDb::kForWrite))
	{
		pEnt1->erase();
		pEnt1->close();
	}
	return TRUE;
}

//后续轴号增加 2
BOOL KTAxisCmdGroup::NextLableIncrease(AcArray<ADimBs>& arDb1, int nNext, int nAddNo)
{
	for (int i = nNext;i < arDb1.length();i++)
	{
		ADimBs &adbs1 = arDb1.at(i);

		OPENOBJ_BEGIN(adbs1.id, AcDb::kForWrite, AcDbBlockReference, pBlkRef);
		if (pBlkRef == NULL)
		{
			return 0;
		}

		AcDbObjectIterator *pIT = pBlkRef->attributeIterator();
		if (pIT == NULL)
			return 0;

		pIT->start();
		AcDbObjectId idAttr = pIT->objectId();
		delete pIT;
		if (!idAttr.isValid())
			return 0;

		AcDbAttribute *pAttr = NULL;
		pBlkRef->openAttribute(pAttr, idAttr, AcDb::kForWrite);
		if (pAttr == NULL)
			return 0;

		LPTSTR pszText = pAttr->textString();

		CString sTxt;
		sTxt.Format(_T("%d"), _ttoi(pszText) + nAddNo);
		pAttr->setTextString(sTxt);

		acutDelString(pszText);
		
		pAttr->close();

		OPENOBJ_END();
	}
	return TRUE;
}

int KTAxisCmdGroup::AddAxisLabel()
{
	CString sLayEn, sLayCn;
	KTSetting::InitLayer(_T("LAY_DIMAX"));
	KTSetting::GetLayerName(_T("LAY_DIMAX"), sLayEn, sLayCn);
	KTCADSysVar<LPCTSTR, TRUE> clayer(_T("CLAYER"), sLayEn);

	double dScale = 100.0;
	GetDocScale(dScale);

	struct resbuf *pResbuf = acutBuildList(RTDXF0, _T("INSERT"), 8, sLayEn, 0); ;

	CString sText;
	sText = _T("\n请选择添补在它之后的轴号<退出>:");

	ads_name entAxis;
	ads_point pt;
	if (RTNORM != CKTCadUtility::SelectEntity1(sText, entAxis, pResbuf, pt))
	{
		acutRelRb(pResbuf);
		return 0;
	}

	AcDbObjectId id,idLn;
	acdbGetObjectId(id, entAxis);

	//获取轴号的参考位置
	AcGePoint3d ptOn,ptBase;
	if (!GetAxisDimBasePoint(id, idLn, ptOn,ptBase))
	{
		acutRelRb(pResbuf);
		acutPrintf(_T("\n没有找到轴号的直线基点!"));
		return 0;
	}

	//获取双侧排序的轴号
	AcArray<ADimBs> arDb1, arDb2;
	Get2SideAxisDim(arDb1, arDb2, ptOn, ptBase);
	
	ads_point pt1, pt2,pt22;
	acdbWcs2Ucs(asDblArray(ptBase), pt1,false);

	if (RTNORM == acedGetPoint(pt1, _T("\n请点取新轴号的位置:"), pt2))
	{
		//复制一对轴标，然后改数值,后续依次加1
		for(int i = 0;i < arDb1.length();i++)
		{
			if (arDb1.at(i).id == id)
			{
				acdbUcs2Wcs(pt2, pt22, false);
				AcGeVector3d vtN = ptOn - ptBase;
				AcGeVector3d vtM = asPnt3d(pt22) - ptBase;
				vtM = vtM.orthoProject(vtN);
				AcGeMatrix3d xM; xM.setToTranslation(vtM);

				if (i < arDb2.length() )
				{
					InsertAxisLable(arDb1.at(i), xM);
					// arDb1和arDb2数量可能不等，保护
					if (i < arDb2.length())
						InsertAxisLable(arDb2.at(i), xM);

					//后续轴号增加 2
					NextLableIncrease(arDb1,i + 1,1);
					NextLableIncrease(arDb2,i + 1,1);
				}
				break;
			}
		}
	}

	acutRelRb(pResbuf);
	return 1;
}

int KTAxisCmdGroup::DelAxisLabel()
{

	CString sLayEn, sLayCn;
	KTSetting::InitLayer(_T("LAY_DIMAX"));
	KTSetting::GetLayerName(_T("LAY_DIMAX"), sLayEn, sLayCn);
	KTCADSysVar<LPCTSTR, TRUE> clayer(_T("CLAYER"), sLayEn);

	double dScale = 100.0;
	GetDocScale(dScale);

	struct resbuf *pResbuf = acutBuildList(RTDXF0, _T("INSERT"), 8, sLayEn, 0); ;

	CString sText;
	sText = _T("\n请选择要删除的轴号<退出>:");

	ads_name entAxis;
	ads_point pt;
	if (RTNORM != CKTCadUtility::SelectEntity1(sText, entAxis, pResbuf, pt))
	{
		acutRelRb(pResbuf);
		return 0;
	}

	AcDbObjectId id,idLn;
	acdbGetObjectId(id, entAxis);

	//获取轴号的参考位置
	AcGePoint3d ptOn, ptBase;
	if (!GetAxisDimBasePoint(id, idLn,ptOn, ptBase))
	{
		acutRelRb(pResbuf);
		acutPrintf(_T("\n没有找到轴号的直线基点!"));
		return 0;
	}

	//获取双侧排序的轴号
	AcArray<ADimBs> arDb1, arDb2;
	Get2SideAxisDim(arDb1, arDb2, ptOn, ptBase);

	for (int i = 0; i < arDb1.length(); i++)
	{
		if (arDb1.at(i).id == id)
		{
			EraseAxisLable(arDb1.at(i));
			// arDb1和arDb2数量可能不等，保护
			if (i < arDb2.length())
				EraseAxisLable(arDb2.at(i));

			//后续轴号减去 1
			NextLableIncrease(arDb1, i + 1, -1);
			NextLableIncrease(arDb2, i + 1, -1);

			break;
		}
	}
	return 1;
}

BOOL KTAxisCmdGroup::OnDimSingleAxisCurve(AcGePoint3d& ptPick, ads_name ent, BOOL bDouble)
{
	AcGePoint3d ptCur, ptOth;
	AcGeVector3d vecCur, vecOth;

	AcDbObjectId idEnt;
	acdbGetObjectId(idEnt,ent);

	OPENOBJ_BEGIN(idEnt, AcDb::kForRead, AcDbCurve, pCurve);
	if (pCurve == NULL)
		return FALSE;
	if (pCurve->isKindOf(AcDbLine::desc()))
	{
		AcGePoint3d ptStart, ptEnd;
		pCurve->getStartPoint(ptStart);
		pCurve->getEndPoint(ptEnd);
		ptPick.z = ptEnd.z;

		if (ptPick.distanceTo(ptEnd) > ptPick.distanceTo(ptStart))
		{
			ptCur = ptStart;
			ptOth = ptEnd;
		}
		else
		{
			ptCur = ptEnd;
			ptOth = ptStart;
		}
		vecCur = ptCur - ptOth;
		vecCur.normalize();
		vecOth = -vecCur;
	}
	else
		return FALSE;
	OPENOBJ_END();

	CString sLabel;

	CString sText;
	TCHAR szResult[MAX_PATH];
	sText = _T("\n请输入轴号<空号>:");

	switch(acedGetString(TRUE, sText, szResult))
	{
	case RTNORM:
		sLabel = szResult;
		break;
	case RTNONE:
		break;
	default:
		return FALSE;
	}

	AcDbObjectId idBlk = KTCADUtilityEx::InsertBlock(_T("_AXISO.DWG"));
	if (!idBlk.isValid())
		return FALSE;
	
	CString sLayEn, sLayCn;
	KTSetting::InitLayer(_T("LAY_DIMAX"));
	KTSetting::GetLayerName(_T("LAY_DIMAX"),sLayEn,sLayCn);
	KTCADSysVar<LPCTSTR,TRUE> clayer(_T("CLAYER"), sLayEn);

	double dScale = 100.0;
	GetDocScale(dScale);
	double dHeight = 4.0 * dScale;
	AcGeScale3d scScale(dHeight * 2.0);

	AcGeVector3d vecCurLeader = vecCur * 40.0 * dScale;
	AcGeVector3d vecOthLeader = vecOth * 40.0 * dScale;

	AcGeVector3d vecCurLabel = vecCurLeader + vecCur * dHeight;
	AcGeVector3d vecOthLabel = vecOthLeader + vecOth * dHeight;

	AcDbObjectIdArray aridLabel;

	AcDbObjectId idTemp;

	// 当前侧轴标
	AcDbLine* pLine = new AcDbLine(ptCur, ptCur + vecCurLeader);
	ASSERT(pLine != NULL);
	pLine->setLayer(sLayEn);
	CKTCadUtility::AddToBlockTableRecord(idTemp,pLine);
	pLine->close();
	aridLabel.append(idTemp);

	AcDbBlockReference* pRef = new AcDbBlockReference(ptCur + vecCurLabel, idBlk);
	ASSERT(pRef != NULL);
	pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
	pRef->setLayer(sLayEn);
	pRef->setScaleFactors(scScale);
	CKTCadUtility::AddToBlockTableRecord(idTemp,pRef);
	aridLabel.append(idTemp);
	KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
	pRef->close();

	// 另一侧轴标
	if (bDouble)
	{
		pLine = new AcDbLine(ptOth, ptOth + vecOthLeader);
		ASSERT(pLine != NULL);
		pLine->setLayer(sLayEn);
		CKTCadUtility::AddToBlockTableRecord(pLine);
		pLine->close();
		pRef = new AcDbBlockReference(ptOth + vecOthLabel, idBlk);
		ASSERT(pRef != NULL);
		pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
		pRef->setScaleFactors(scScale);
		pRef->setLayer(sLayEn);
		CKTCadUtility::AddToBlockTableRecord(pRef);
		KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
		pRef->close();
	}
	return TRUE;
}

BOOL KTAxisCmdGroup::GetPalsFrom2Curve(AcDbObjectIdArray& arId,const AcDbObjectId& idFr,const AcDbObjectId& idTo)
{
	AcDbExtents ext1,ext2;
	AcDbEntity* pEnt1 = NULL,*pEnt2 = NULL;
	AcGeVector3d vt1,vt2;

	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1,idFr,AcDb::kForRead))
	{
		pEnt1->getGeomExtents(ext1);
		AcDbLine* pLine1 = AcDbLine::cast(pEnt1);
		if (pLine1 != NULL)
		{
			vt1 = pLine1->endPoint() - pLine1->startPoint();
		}
		pEnt1->close();
	}

	if (Acad::eOk == acdbOpenAcDbEntity(pEnt2,idTo,AcDb::kForRead))
	{
		pEnt2->getGeomExtents(ext2);
		AcDbLine* pLine2 = AcDbLine::cast(pEnt2);
		if (pLine2 != NULL)
		{
			vt2 = pLine2->endPoint() - pLine2->startPoint();
		}
		pEnt2->close();
	}

	ext1.addExt(ext2);
	AcGePoint3d ptMin,ptMax;
	ptMin = ext1.minPoint();
	ptMax = ext1.maxPoint();

	ads_point pt1,pt2,pt11,pt22;
	pt1[X] = ptMin.x - 10.0;pt1[Y] = ptMin.y - 10.0;pt1[Z] = __max(ptMin.z,ptMax.z);
	pt2[X] = ptMax.x + 10.0;pt2[Y] = ptMax.y + 10.0;pt2[Z] = __max(ptMax.z,ptMin.z);

	acdbWcs2Ucs(pt1, pt11,false);
	acdbWcs2Ucs(pt2, pt22,false);

	CKTCadUtility::ZoomInCurrentView(ptMin,ptMax);

	CString sLayEn, sLayCn;
	KTSetting::InitLayer(_T("LAY_AXIS"));
	KTSetting::GetLayerName(_T("LAY_AXIS"),sLayEn,sLayCn);

	// 创建过滤条件
	KTTempTol TempTol(0.001);
	struct resbuf * pResbuf = NULL;
	pResbuf = acutBuildList(RTDXF0, _T("LINE"), 8, sLayEn, 0); 

	ads_name ss;
	acedSSGet(_T("C"),pt11, pt22,pResbuf,ss);

	AcDbObjectId id;
	Adesk::Int32 lLen = 0;
	acedSSLength(ss,&lLen);
	ads_name ent;
	AcGeVector3d vt3;

	for (int i = 0;i < lLen;i++)
	{
		acedSSName(ss,i,ent);
		if (Acad::eOk == acdbGetObjectId(id,ent))
		{
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt1,id,AcDb::kForRead))
			{
				AcDbLine* pLine3 = AcDbLine::cast(pEnt1);
				if (pLine3 != NULL)
				{
					vt3 = pLine3->endPoint() - pLine3->startPoint();
					if (vt1.isParallelTo(vt3))
					{
						arId.append(id);
					}
				}
				pEnt1->close();
			}
		}
	}
	return arId.length() > 0;
}

BOOL KTAxisCmdGroup::GetDocScale(double& dPScale)
{
	//获取初始化数据
	AecDbObjXDataMap xDataMap;
	KTModelLayoutXData::ReSet(xDataMap);

	if (!KTModelLayoutXData::ReadModelXData(KT_PIPEINIT,xDataMap))
	{
		acedAlert(_T("\n系统未初始化!"));
		return 0;
	}

	CString sDocScale = "";
	xDataMap.GetAt(_T("Scale"),sDocScale);
	int nIndex = sDocScale.Find(':',0);
	dPScale = 1.0;
	if (nIndex != -1)
	{
		dPScale = _ttof(sDocScale.Mid(nIndex + 1)) / _ttof(sDocScale.Mid(0,nIndex));
	}
	return TRUE;
}

BOOL KTAxisCmdGroup::OnDimParallelAxisLine(AcDbObjectIdArray& ssSet, ads_name entCurEdge,ads_name entOthEdge)
{	
	AcDbObjectId identCurEdge,identOthEdge;
	acdbGetObjectId(identCurEdge,entCurEdge);
	acdbGetObjectId(identOthEdge,entOthEdge);

	AcDbObjectId idBlk = KTCADUtilityEx::InsertBlock(_T("_AXISO.DWG"));
	if (!idBlk.isValid())
	{
		return FALSE;
	}
	
	CString sLay,sNameFr;
	AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_DIMAX"));
	KTSetting::GetLayerName(_T("LAY_DIMAX"),sLay,sNameFr);

	KTCADSysVar<LPCTSTR,TRUE> clayer(_T("CLAYER"), sLay);
	AcDbObjectId idLineStyle = KTSetting::InitDimStyle(_T("DS_LINEAR"));

	double dScale = 1.0;
	GetDocScale(dScale);
	double dHeight = 4.0 * dScale;
	AcGeScale3d scScale(dHeight * 2.0);

	// 标注开始点
	AcGePoint3d ptCurPos = m_ptCurStart;
	AcGePoint3d ptOthPos = m_ptOthStart;

	// 标注方向
	AcGeVector3d vecCurDir = m_ptCurEnd - m_ptCurStart;
	vecCurDir.normalize();
	AcGeVector3d vecOthDir = m_ptOthEnd - m_ptOthStart;
	vecOthDir.normalize();

	// 标号引线方向长度
	AcGeVector3d vecCurLeader = m_vecCur * 40.0 * dScale;
	AcGeVector3d vecOthLeader = m_vecOth * 40.0 * dScale;

	// 标号位置方向长度
	AcGeVector3d vecCurLabel = vecCurLeader + m_vecCur * dHeight;
	AcGeVector3d vecOthLabel = vecOthLeader + m_vecOth * dHeight;

	// 尺寸标注位置方向长度
	AcGeVector3d vecCurDimPos = m_vecCur * 25.0 * dScale;
	AcGeVector3d vecOthDimPos = m_vecOth * 25.0 * dScale;

	// 当前尺寸标注起点和终点
	AcGePoint3d ptCurDimStart = m_ptCurStart;
	AcGePoint3d ptCurDimEnd = m_ptCurStart;
	AcGePoint3d ptOthDimStart = m_ptOthStart;
	AcGePoint3d ptOthDimEnd = m_ptOthStart;
	
	// 标注旋转角度
	double dCurAngle = acutAngle(asDblArray(m_ptCurStart), asDblArray(m_ptCurEnd));
	double dOthAngle = acutAngle(asDblArray(m_ptOthStart), asDblArray(m_ptOthEnd));
	
	// 当前标号
	CString sLabel = m_sStartLabel;

	// 当前轴线是否标注标号和尺寸
	BOOL bCurExtOut = TRUE;
	BOOL bOthExtOut = TRUE;

	// 标注实体Id组
	AcDbObjectIdArray aridCurLabel;
	AcDbObjectIdArray aridOthLabel;
	AcDbObjectIdArray aridCurDim;
	AcDbObjectIdArray aridOthDim;
	
	double dInterval;
	//
	AcGePoint3d ptTemp;
	AcDbObjectId idTemp;
	//
	AcDbLine* pLine;
	AcDbDimension* pDim;
	AcDbBlockReference* pRef;

	// 起始和终止循环
	long l, lStep, lPrev;
	long lLen = ssSet.length() - 1l;
	if (m_bUpside)
	{
		l = lLen;
		lStep = -1l;
	}
	else
	{
		l = 0l;
		lStep = 1l;
	}

	CString sCurLabel, sOthLabel;
	AcGePoint3d ptCurLabel, ptCur1, ptCur2, ptOthLabel, ptOth1, ptOth2;
	BOOL bDrawCur = TRUE, bDrawOth = TRUE;

	// 当前侧轴标
	if (bDrawCur && IsLabelCurrent())
	{
		pLine = new AcDbLine(ptCurPos, ptCurPos + vecCurLeader);
		ASSERT(pLine != NULL);
		pLine->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pLine);
		pLine->close();
		aridCurLabel.append(idTemp);
		pRef = new AcDbBlockReference(ptCurPos + vecCurLabel, idBlk);
		ASSERT(pRef != NULL);
		pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
		pRef->setLayer(sLay);
		pRef->setScaleFactors(scScale);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pRef);
		aridCurLabel.append(idTemp);
		KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
		pRef->close();
	}

	// 另一侧轴标
	if (bDrawOth && IsLabelAnother())
	{
		pLine = new AcDbLine(ptOthPos, ptOthPos + vecOthLeader);
		ASSERT(pLine != NULL);
		pLine->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pLine);
		pLine->close();
		aridOthLabel.append(idTemp);
		pRef = new AcDbBlockReference(ptOthPos + vecOthLabel, idBlk);
		ASSERT(pRef != NULL);
		pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
		pRef->setScaleFactors(scScale);
		pRef->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pRef);
		aridOthLabel.append(idTemp);
		KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
		pRef->close();
	}

	AcGePoint3dArray arpt;
	for (lPrev = l, l += lStep; l > 0l && l < lLen; l += lStep, lPrev += lStep)
	{
		// 偏移
		dInterval = KTCADUtilityEx::GetParallelAxisLineInterval(ssSet[lPrev], ssSet[l]);
		sLabel = KTCADUtilityEx::GetNewAxisLabel(sLabel, TRUE);
		ptCurPos += vecCurDir * dInterval;
		ptOthPos += vecOthDir * dInterval;
		ptCurDimEnd = ptCurPos;
		ptOthDimEnd = ptOthPos;
		bCurExtOut = KTCADUtilityEx::IsLinesIntersect(ptCurPos, vecCurDir, ssSet[l]);
		bOthExtOut = KTCADUtilityEx::IsLinesIntersect(ptOthPos, vecOthDir, ssSet[l]);
		OPENOBJ_BEGIN(ssSet[l], AcDb::kForRead, AcDbCurve, pCurve);
		if (pCurve != NULL)
		{
			arpt.setLogicalLength(0);
			OPENOBJ_BEGIN(identCurEdge, AcDb::kForRead, AcDbCurve, pEdge);
			if (pEdge != NULL)
				bCurExtOut = (pCurve->intersectWith(pEdge, AcDb::kOnBothOperands, arpt) == Acad::eOk && !arpt.isEmpty());
			OPENOBJ_END();
			arpt.setLogicalLength(0);
			OPENOBJ_BEGIN(identOthEdge, AcDb::kForRead, AcDbCurve, pEdge);
			if (pEdge != NULL)
				bOthExtOut = (pCurve->intersectWith(pEdge, AcDb::kOnBothOperands, arpt) == Acad::eOk && !arpt.isEmpty());
			OPENOBJ_END();
		}
		OPENOBJ_END();

		// 当前侧尺寸
		if (IsDimCurrent() && bCurExtOut)
		{
			ptTemp = KTCADUtilityEx::GetCenterPoint(ptCurDimStart, ptCurDimEnd) + vecCurDimPos;
			pDim = new AcDbRotatedDimension(dCurAngle, ptCurDimStart, ptCurDimEnd, ptTemp, NULL, idLineStyle);
			pDim->setElevation(ptTemp.z);
			ASSERT(pDim != NULL);
			pDim->setHorizontalRotation(-CKTCadUtility::Ucs2Wcs(0.0));
			pDim->setLayer(sLay);
			CKTCadUtility::AddToBlockTableRecord(idTemp,pDim);
			pDim->close();
			aridCurDim.append(idTemp);
			ptCurDimStart = ptCurDimEnd;
		}

		// 另一侧尺寸
		if (IsDimAnother() && bOthExtOut)
		{
			ptTemp = KTCADUtilityEx::GetCenterPoint(ptOthDimStart, ptOthDimEnd) + vecOthDimPos;
			pDim = new AcDbRotatedDimension(dOthAngle, ptOthDimStart, ptOthDimEnd, ptTemp, NULL, idLineStyle);
			pDim->setElevation(ptTemp.z);
			ASSERT(pDim != NULL);
			pDim->setHorizontalRotation(-CKTCadUtility::Ucs2Wcs(0.0));
			pDim->setLayer(sLay);
			CKTCadUtility::AddToBlockTableRecord(idTemp,pDim);
			pDim->close();
			aridOthDim.append(idTemp);
			ptOthDimStart = ptOthDimEnd;
		}
		// 当前侧轴标
		if (IsLabelCurrent() && bCurExtOut)
		{
			pLine = new AcDbLine(ptCurPos, ptCurPos + vecCurLeader);
			ASSERT(pLine != NULL);
			pLine->setLayer(sLay);
			CKTCadUtility::AddToBlockTableRecord(idTemp,pLine);
			pLine->close();
			aridCurLabel.append(idTemp);
			pRef = new AcDbBlockReference(ptCurPos + vecCurLabel, idBlk);
			ASSERT(pRef != NULL);
			pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
			pRef->setLayer(sLay);
			pRef->setScaleFactors(scScale);
			CKTCadUtility::AddToBlockTableRecord(idTemp,pRef);
			aridCurLabel.append(idTemp);
			KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
			pRef->close();
		}
		// 另一侧轴标
		if (IsLabelAnother() && bOthExtOut)
		{
			pLine = new AcDbLine(ptOthPos, ptOthPos + vecOthLeader);
			ASSERT(pLine != NULL);
			pLine->setLayer(sLay);
			CKTCadUtility::AddToBlockTableRecord(idTemp,pLine);
			pLine->close();
			aridOthLabel.append(idTemp);
			pRef = new AcDbBlockReference(ptOthPos + vecOthLabel, idBlk);
			ASSERT(pRef != NULL);
			pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
			pRef->setScaleFactors(scScale);
			pRef->setLayer(sLay);
			CKTCadUtility::AddToBlockTableRecord(idTemp,pRef);
			aridOthLabel.append(idTemp);
			KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
			pRef->close();
		}
	}
	
	// 偏移
	if (l < 0) l = ssSet.length() - 1;
	dInterval = KTCADUtilityEx::GetParallelAxisLineInterval(ssSet[lPrev], ssSet[l]);
	sLabel = KTCADUtilityEx::GetNewAxisLabel(sLabel, TRUE);
	ptCurPos += vecCurDir * dInterval;
	ptOthPos += vecOthDir * dInterval;
	ptCurDimEnd = ptCurPos;
	ptOthDimEnd = ptOthPos;
	// 当前侧尺寸
	if (IsDimCurrent())
	{
		ptTemp = KTCADUtilityEx::GetCenterPoint(ptCurDimStart, ptCurDimEnd) + vecCurDimPos;
		pDim = new AcDbRotatedDimension(dCurAngle, ptCurDimStart, ptCurDimEnd, ptTemp, NULL, idLineStyle);
		pDim->setElevation(ptTemp.z);
		ASSERT(pDim != NULL);
		pDim->setHorizontalRotation(-CKTCadUtility::Ucs2Wcs(0.0));
		pDim->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pDim);
		pDim->close();
		aridCurDim.append(idTemp);
		ptCurDimStart = ptCurDimEnd;
	}
	// 另一侧尺寸
	if (IsDimAnother())
	{
		ptTemp = KTCADUtilityEx::GetCenterPoint(ptOthDimStart, ptOthDimEnd) + vecOthDimPos;
		pDim = new AcDbRotatedDimension(dOthAngle, ptOthDimStart, ptOthDimEnd, ptTemp, NULL, idLineStyle);
		pDim->setElevation(ptTemp.z);
		ASSERT(pDim != NULL);
		pDim->setHorizontalRotation(-CKTCadUtility::Ucs2Wcs(0.0));
		pDim->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pDim);
		pDim->close();
		aridOthDim.append(idTemp);
		ptOthDimStart = ptOthDimEnd;
	}
	
	// 当前侧轴标
	if (IsLabelCurrent())
	{
		pLine = new AcDbLine(ptCurPos, ptCurPos + vecCurLeader);
		ASSERT(pLine != NULL);
		pLine->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pLine);
		pLine->close();
		aridCurLabel.append(idTemp);
		pRef = new AcDbBlockReference(ptCurPos + vecCurLabel, idBlk);
		ASSERT(pRef != NULL);
		pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
		pRef->setLayer(sLay);
		pRef->setScaleFactors(scScale);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pRef);

		aridCurLabel.append(idTemp);
		KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
		pRef->close();
	}
	// 另一侧轴标
	if (IsLabelAnother())
	{
		pLine = new AcDbLine(ptOthPos, ptOthPos + vecOthLeader);
		ASSERT(pLine != NULL);
		pLine->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pLine);
		pLine->close();
		aridOthLabel.append(idTemp);
		pRef = new AcDbBlockReference(ptOthPos + vecOthLabel, idBlk);
		ASSERT(pRef != NULL);
		pRef->setRotation(-CKTCadUtility::Wcs2Ucs(0.0));
		pRef->setScaleFactors(scScale);
		pRef->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pRef);
		aridOthLabel.append(idTemp);
		KTCADUtilityEx::AppendAttribute(pRef, _T("A"), sLabel);
		pRef->close();
	}

	// 当前侧总尺寸
	if (IsDimCurrent())
	{
		ptTemp = KTCADUtilityEx::GetCenterPoint(m_ptCurStart, m_ptCurEnd) + vecCurDimPos + vecCurDimPos.normal() * 8.0 * dScale;
		pDim = new AcDbRotatedDimension(dCurAngle, m_ptCurStart, m_ptCurEnd, ptTemp, NULL, idLineStyle);
		pDim->setElevation(ptTemp.z);
		ASSERT(pDim != NULL);
		pDim->setHorizontalRotation(-CKTCadUtility::Ucs2Wcs(0.0));
		pDim->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pDim);
		pDim->close();
		aridCurDim.append(idTemp);
	}
	// 另一侧总尺寸
	if (IsDimAnother())
	{
		ptTemp = KTCADUtilityEx::GetCenterPoint(m_ptOthStart, m_ptOthEnd) + vecOthDimPos + vecOthDimPos.normal() * 8.0 * dScale;
		pDim = new AcDbRotatedDimension(dOthAngle, m_ptOthStart, m_ptOthEnd, ptTemp, NULL, idLineStyle);
		pDim->setElevation(ptTemp.z);
		ASSERT(pDim != NULL);
		pDim->setHorizontalRotation(-CKTCadUtility::Ucs2Wcs(0.0));
		pDim->setLayer(sLay);
		CKTCadUtility::AddToBlockTableRecord(idTemp,pDim);
		pDim->close();
		aridOthDim.append(idTemp);
	}	
	return TRUE;
}