//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   内部全局函数实现文件
// = Version	:   ver2.0
// = Author		:   tg
// = CreateDate	:   2002-09-09
// = Description:   内部全局函数的定义
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#ifndef _XPRIVATE_H_
#define _XPRIVATE_H_

#include "dbcfilrs.h"

#ifndef _XPOINT_H_
#include "XPoint.h"
#endif

#ifndef _XPOLY2D_H_
#include "XPoly2D.h"
#endif

#ifndef _XCURVESEGMENT_H_
#include "XCurveSegment.h"
#endif

#ifndef _XMASTERPROPERTIES_H_
#include "XMasterProperties.h"
#endif

#ifndef _XEXPLODESTREAMBASE_H_
#include "XExplodeStreamBase.h"
#endif

#ifndef _XASTRINGLIST_H_
#include "XAStringList.h"
#endif

#ifndef _XTRIANGLE_H_
#include "XTriangle.h"
#endif

#ifndef _XPOLYGONEX_H_
#include "XPolygonEx.h"
#endif

#ifndef _GROUPS_H_
#include "Groups.h"
#endif

#ifndef _CENTITY_H_
#include "CEntity.h"
#endif

#ifndef _C3DFACE_H_
#include "C3DFace.h"
#endif

#ifndef  _XGLOBALFUNC_H_
#include "XGlobalFunc.h"
#endif

#ifndef  _XPOLYDIST_H_
#include "XPolyDist.h"
#endif

#include <vector>

#if ARX < 17
#include "istream.h"
#endif

class XConfigBase;
class XSortWallOnPt;

namespace XPrivate
{
	// 比较两个id是否相等
	GEOAPI int CompareObjectId(const AcDbObjectId *id1, const void *id2);
	GEOAPI int CompareObjectId(const AcDbSoftPointerId *id1, const void *id2);
	
	//函数作参数	
	GEOAPI int CompNodeByEqual(const XSortWallOnPt *p1, const void *p2);
	
	//不判断顶点
	GEOAPI int HitTestOnEdge(const AcDbFace *pFace, XPoint pt, bool bDiscardHideEdge);
	
	GEOAPI int GetApplicationPath(TCHAR *vPath, HINSTANCE hInstance);
	
	GEOAPI int AT_get_cirarcp(ads_name arc_ent,ads_point cent,ads_real *rad,ads_real *sang,ads_real *eang);

	GEOAPI void FixGsView();
	
	GEOAPI void RemoveDup();
	GEOAPI void CircleToPoly(const XCircle &cir, XPoly &poly, int nDiv);
	
	GEOAPI void DrawCircle(AcGiWorldDraw *pWd, AcGiViewportDraw *pVd, const XCircle &cir, ads_real nHeight);
	GEOAPI void DrawCircle(AcGiWorldDraw *pWd, AcGiViewportDraw *pVd, const XCircle &cir);
	GEOAPI void DrawLineSeg(XExplodeDraw &dc, const XLine &ln,	ads_real nHeight, int bShowStart, int bShowEnd);
	GEOAPI void DrawLineSeg(AcGiWorldDraw *pWd, AcGiViewportDraw *pVd, const XLine &ln);
	GEOAPI void DrawArcSeg(AcGiWorldDraw *pWd, AcGiViewportDraw *pVd, const XArc &ar);
	GEOAPI void DrawArcSeg(XExplodeDraw &dc, const XArc &ar,ads_real nHeight, int bShowStart, int bShowEnd);

	GEOAPI void AsPolyline(const AcDbLine &line, AcDbPolyline &pline);
	GEOAPI void AsPolyline(const AcDbArc &line, AcDbPolyline &pline);
	GEOAPI void AsPolyline(const AcDbCircle &line, AcDbPolyline &pline);
	
	GEOAPI void _RemoveDupCurves(DList<XCurveSegment> &lstCurves);
	
	GEOAPI void RemoveDupNoXData();
	GEOAPI void RemoveExactDupLines(DList<XCurveSegment> &lstCurves);

	GEOAPI void ThickPoly2Face(XMasterProperties prop, const XPoly2D &poly, XPoint vtNormal, 
		double nThick, AcDbVoidPtrArray &entSet, AcGeMatrix3d *pMatTran = NULL);

	GEOAPI int AT_in_arc(ads_point pt, ads_point cenpt, ads_real rad, ads_real ang1, ads_real ang2);
	GEOAPI int AT_pt_ProjectLine(ads_point src_pt, ads_point cl_pt1, ads_point cl_pt2, ads_point dest_pt);
	GEOAPI int AT_in_line(ads_point pt, ads_point line_pt1,ads_point line_pt2);

	//测试PT2在PT0-PT1之哪边：1：左边，2：右边，0：共线
	GEOAPI int PtAtWhichSide(const AcGePoint3d& pt0,const AcGePoint3d& pt1,const AcGePoint3d& pt2,double tol = TOL);
	
	GEOAPI int GetPickFirst(PickSet &gSet, PickSet &pSet);

	GEOAPI AcGeMatrix3d BlockTransform(const AcDbBlockReference *pInsert);
	
	GEOAPI ads_real GetXDirection(const XCurveSegment &cv1, const XCurveSegment &cv2,  const XPoint &ptLoc);
	
	GEOAPI int _Subtract(const XPoly2D &poly1, const DList<XPoly2D> &lstPoly2, DList<XPoly2D> &lstResult);
	GEOAPI XPoint GetAutoDelPt(XPoint ptRef, XPoint pt1, XPoint pt2);

	GEOAPI double GetPolygonDist(const XPolygonEx &poly1, const XPolygonEx &poly2);

	//判断两线段是否重合
	GEOAPI BOOL IsEqual(const AcGePoint3d pt11,const AcGePoint3d pt12,const AcGePoint3d pt21,const AcGePoint3d pt22,double tol = TOL);

	//判断由p11-p12与p21-p22所在直线是否重合
	GEOAPI BOOL IsOverlap(AcGePoint3d& pt11,AcGePoint3d& pt12,AcGePoint3d& pt21,AcGePoint3d& pt22);

	GEOAPI BOOL SkipSubErase(const TCHAR *szCmd);

	//构造孔板,即外边界和洞之间区域的三角化。
	//失败原因：1、洞或者最外边界不封闭
	//			2、边界线相交
	//			3、孔中包含有孔
	//			4、选择了没有外边界的孔
	//自动搜索最外边界
	GEOAPI BOOL Triangulate(const DList<XPoly2D> &lstHole,DList<XTriangle> &lstRes);
	//自动搜索最外边界
	GEOAPI BOOL Triangulate(const DList<XPolygonEx> &lstHole,DList<XTriangle> &lstRes);
	//给定最外边界
	GEOAPI BOOL Triangulate(const XPoly2D &out,const DList<XPoly2D> &lstHole,DList<XTriangle> &lstRes);
	//给定最外边界
	GEOAPI BOOL Triangulate(const XPolygonEx &out,const DList<XPoly2D> &lstHole,DList<XTriangle> &lstRes);
	//给定最外边界
	GEOAPI BOOL Triangulate(const XPolygonEx &out,const DList<XPolygonEx> &lstHole,DList<XTriangle> &lstRes);

	GEOAPI BOOL IsPointAtSameSide(const AcGePlane& plane, const AcGePoint3d& pt1, const AcGePoint3d& pt2);
	
	GEOAPI PGroups VBuildList(int *);

#if (ARX>15)
	//去除EXE中的RT＿MANIFEST资源
	GEOAPI bool RemoveRT_MANIFEST(const TCHAR* fullPath,int resId);
#endif

	GEOAPI XString OsMode2Str(int nMode);
	GEOAPI BOOL SearchPathFromCurve(const DList<XCurveSegment> &curves, XPoly2D &polyPath);
	
	GEOAPI XPoint GetTextExtend(AcDbObjectId idTextStyle, const TCHAR *pszText, double nHeight, BOOL penups);

	GEOAPI char* xh3cpy(char *, char *, int);
	GEOAPI char* xh2cpy(char *, char *, int);
	GEOAPI void xh1cpy(char *to, const char *from);
	
	GEOAPI TCHAR *strnew_delspace(const TCHAR *src);

	GEOAPI double GetViewportPScale(int cvport);

	GEOAPI int ConnectPolygons(DList<XPolygonEx> &lstPolygons, XPolygonEx &polyEx1);
	GEOAPI int ConnectPolygonsNew(DList<XPolygonEx> &lstPolygons, XPolygonEx &polyEx1);

	// 判断桥接是否合适，即不和任何边有交点（位于边内）
	GEOAPI BOOL IsGoodConnector(const XLine &lnConnector, const XPolygonEx &rPolygon);
	// 取得连接桥
	GEOAPI int GetConnector(const XPolygonEx &poly1, const XPolygonEx &poly2, XLine &lnConnector);
	// 判断桥接是否合适
	GEOAPI BOOL IsGoodConnector(const XLine &lnConnector, const DList<XPolygonEx> &lstPolygons, int idxExclude);
	
	// 求两线之间的最短距离// 注: 算法不最优(用排序求最小值)
	GEOAPI ads_real MinDistance(const XLine &ln1, const XLine &ln2, XPoint &ptInt1, XPoint &ptInt2);
	// result.nIndex1没有赋值, 留给调用程序赋值// 注: 算法不最优(用排序求最小值)
	GEOAPI int MinDistance(XLine &ln1, XPolygonEx &poly2, XPolyDist &result);
	// 请两多边形的最短距离// 注: 算法不最优(用排序求最小值)
	GEOAPI int MinDistance(XPolygonEx &poly1, XPolygonEx &poly2, XPolyDist &result);

	GEOAPI double GetAnglePrecFromRadius(double radius);
	GEOAPI double GetParaPrecFromLength(double length);
	GEOAPI bool IsParaInSeg(double pa,double prec);

	GEOAPI void AT_xformpt(ads_matrix xform,ads_point pt,ads_point newpt);
	GEOAPI ads_real AT_Dist_PtLine2(ads_point pt0, ads_point pt1,ads_point pt2);

	GEOAPI Acad::ErrorStatus ReadCurve(AcDbDwgFiler *pFiler, XCurveSegment &seg);
	GEOAPI Acad::ErrorStatus ReadCurveList(AcDbDwgFiler *pFiler, DList<XCurveSegment> &lstSegs);
	GEOAPI Acad::ErrorStatus WriteCurve(AcDbDwgFiler *pFiler, const XCurveSegment &seg);
	GEOAPI Acad::ErrorStatus WriteCurveList(AcDbDwgFiler *pFiler, const DList<XCurveSegment> &lstSegs);
		
	GEOAPI XCurveSegment GetMaxCurveAfterClip(const XCurveSegment &cvSource, const XPoly2D &sPoly, const XPoly2D &ePoly);
	GEOAPI XCurveSegment GetCurveContainPointAfterClip(XPoint ptPick,const XCurveSegment &cvSource, const XPoly2D &sPoly, const XPoly2D &ePoly);
	
	template <class K> BOOL CopyObject(const K &src, K &dest)
	{
		AcDbDeepCloneFiler filer;
		BOOL bRet = FALSE;
		if (src.dwgOutFields(&filer) == Acad::eOk) 
		{
			filer.seek(0L,0);
			bRet = (dest.dwgInFields(&filer) == Acad::eOk);
		}
		
		return bRet;
	}
	
	GEOAPI int MakeArcWallSeg(XExplodeDraw &dc, const XArc &arc, ads_real height, ads_real iDist, ads_real oDist, int bShowStart, int bShowEnd);
	GEOAPI void MakeArcWallSeg(XExplodeDraw &dc,const XArc &iArc, const XArc &oArc, ads_real height, int bShowStart, int bShowEnd);

	GEOAPI void Tessellate(DList<X3DFace> &lstSectFaces, double xBeg, double nStep, int nDivNum, double nHeight, BOOL bHasTop, BOOL bHasBot, BOOL bHasLeft, BOOL bHasRight);
	GEOAPI int AsTriangleFaces(const XPolygonEx &polyOut, const DList<XPoly2D> &lstHoles, DList<X3DFace> &lstFaces);
	GEOAPI int AsTriangleFaces(const XPoly2D &polyOut, const DList<XPoly2D> &lstHoles, DList<X3DFace> &lstFaces);
	
	GEOAPI BOOL CreateReference(AcGePoint3d org,CString& BlockTableRecordName,double rotAng,CString layerName = _T(""));
	//返回实体所在的层名
	GEOAPI CString GetEnityLayer(AcDbObjectId objId);                             
	//构造块名
	GEOAPI BOOL BlockName(CString& blockName);    
	//根据entLst创建块
	GEOAPI BOOL CreateBlock(CEntityList& entLst,CString& blockName,AcDbObjectId& blockId,AcGePoint3d org);
	//返回层layerName的记录ID
	GEOAPI AcDbObjectId GetLayerRecordId(CString layerName);                        

	//只删除C3DFface对象，不删除其AcDbFace对象
	GEOAPI void ReleaseC3DFaceList(C3DFaceList& c3dfaceLst);  
	
	//只删除CEntity对象，不删除其AcDbEntity对象
	GEOAPI void ReleaseCEntityList(CEntityList& centityLst);  
	
	//将链表中的所有实体的层设置为layerName
	GEOAPI void SetLayerOfEntities(CEntityList& entLst,CString layerName, int colorNum = 7);
	
	 //层layerName是否存在于数据库中
	GEOAPI BOOL IsLayerExistInDb(CString layerName);                               
	                        
	//设置层，如果不存在则新建。
	GEOAPI BOOL SetLayer(CString layerName, int colorNum = 0);
	
	//新建层layerName。
	GEOAPI BOOL NewLayer(CString& layerName, int colorNum = 0, BOOL bFreeze = 0);
	
	//将C3DFaceList转换为CEntityList
	GEOAPI void C3DFaceList2EntityList(C3DFaceList& c3dFaceLst,CEntityList& entLst);
	                  
	//将层冻结
	GEOAPI BOOL SetLayerFrozen(CString layerName, bool bFreeze = 1);
	//将层关闭
	GEOAPI BOOL SetLayerOff(CString layerName, bool bOff = 1);

	//判断ECS与UCS的Z轴是否平行1：同向平行，2：反向平行；0：不平行
	GEOAPI int IsZParalECSAndUcs(AcDbObjectId& objId);
	
	//将点从WCS转换到UCS,bVer = 1:转换矢量
	GEOAPI void WCS2UCS(AcGePoint3d& pt,BOOL bVer = 0);
	
	//将点从WCS转换到UCS,bVer = 1:转换矢量
	GEOAPI void UCS2WCS(AcGePoint3d& pt,BOOL bVer = 0);
	
	//将点从ECS转换到UCS,bVer = 1:转换矢量
	GEOAPI void ECS2UCS(AcGePoint3d& pt,AcDbObjectId& objId,BOOL bVer = 0);
	
	//将点从ECS转换到WCS,bVer = 1:转换矢量
	GEOAPI void ECS2WCS(AcGePoint3d& pt,AcDbObjectId& objId,BOOL bVer = 0);
	
	//将点从WCS转换到ECS,bVer = 1:转换矢量
	GEOAPI void WCS2ECS(AcGePoint3d& pt,AcDbObjectId& objId,BOOL bVer = 0);
	
	GEOAPI void UCS2ECS(AcGePoint3d& pt,AcDbObjectId& objId,BOOL bVer = 0);

	//判断一线段与直线是否重合
	GEOAPI BOOL IsOverlap(AcGeLine3d& line1,AcGeLineSeg3d& lineSeg2,const AcGeTol& tol);
	//x1\x2是否同号
	GEOAPI BOOL IsEqualSign(double x1,double x2); 
	
	GEOAPI int xdata_extract_str(struct resbuf **rb, int *num);
	
	GEOAPI int xdata_extract_str(struct resbuf **rb, ads_real *num);
	
	GEOAPI int xdata_extract_strPt(struct resbuf **rb, ads_point pt);
	
	GEOAPI int xdata_extract_str(struct resbuf **rb, TCHAR *str);
	
	GEOAPI int xdata_extract_handle(struct resbuf **rb, TCHAR *str);
	
	GEOAPI int xdata_handle_assoc_single(ads_name ent, int tag, ads_name assoc_ent);
	
	GEOAPI void set_xdata_tag_item(struct resbuf **xdata, int tag,	struct resbuf *tag_xdata, const TCHAR *appname);
	
	GEOAPI struct resbuf * get_xdata_tag_item(struct resbuf *xdata, int tag, struct resbuf **lagptr);
	
	GEOAPI struct resbuf * detach_xdata_tag_item(struct resbuf *xdata, int tag);
	
	GEOAPI int delete_xdata_tag_item(struct resbuf *xdata, int tag);
	
	GEOAPI void add_xdata_tag_braces(struct resbuf **tagdata);
	
	GEOAPI int get_app_xdata(ads_name ent, const TCHAR *apps, struct resbuf **entdata, struct resbuf **xdata);
	
	GEOAPI int AT_setstr_resbuf(struct resbuf *ebuf, const TCHAR * str,int code);

	GEOAPI int MergeCurve(XCurveSegment &curve, XCurveSegment &seg, int bMinusCurve, int bMinusSeg);

	GEOAPI AcDbObject* GetDbConfigObjFromDict(AcDbDictionary *pXDict, AcDb::OpenMode mode);

	GEOAPI AcDbObject * GetDwgGlobalObj(AcDb::OpenMode opMode, AcDbDatabase *pDb);
	
	GEOAPI AcDbObjectId InitDynTextStyle();

	//不封闭pline的裁剪延伸操作，seg与poly同向同心!
	GEOAPI void ModifyXPoly2D(XPoly2D& poly,XCurveSegment seg);
	GEOAPI void ModifyXPoly2DStart(XPoly2D& poly,XCurveSegment seg);
	GEOAPI void ModifyXPoly2DEnd(XPoly2D& poly,XCurveSegment seg);
	GEOAPI void StringToList(const TCHAR *s, XStringList &res, TCHAR cSep);
	GEOAPI int operator == (XStringList &strs1, XStringList &strs2);

	template <class K>
	int xg_setvar(LPCTSTR sym, K val)
	{
		Groups g(val);
		return ads_setvar(sym, (resbuf *)&g);
	}
	
	XConfigBase* GetGlobalConfigBase();
	
	//是否曲线段有效参数
	inline bool IsParaInSeg(double pa)
	{
		return UPEQUAL_ZERO(pa) && DOWNEQUAL_ZERO(pa - 1);
	}
	
	inline double GZeroF()
	{
		return XGeLib::g_fZero;
	}
	
	inline double GZeroA()
	{
		return XGeLib::g_angleZero;
	}
	
	inline double GZeroD()
	{
		return XGeLib::g_distZero;
	}
	
	inline void PSpace(int *vpId = NULL)
	{
		int tileMode;
		xg_getvar(_T("TILEMODE"), &tileMode);
		if (tileMode)
		{
			xg_setvar(_T("TILEMODE"), 0);
		}
		
		if (vpId)
		{
			xg_getvar(_T("CVPORT"), vpId);
		}
		
		SHads_command(RTSTR, _T("PSPACE"), RTNONE);
	}

	inline void MSpace(int vpId = 0)
	{
		SHads_command(RTSTR, _T("MSPACE"), RTNONE);
		if (vpId)
		{
			xg_setvar(_T("CVPORT"), vpId);
		}
	}

	inline resbuf * GetClosedCurveMask()
	{
		return ads_buildlist(-4, _T("<or"), 
			-4, _T("<and"), 
			RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, 
			-4, _T("and>"),
			RTDXF0, _T("CIRCLE"),
			-4, _T("or>"), NULL);
	}

	inline int XGetDist(const TCHAR *szPrmpt, ads_real &r, int nBitFlag = 0)
	{
		XString sDist = XExport::Dist2Str(r);
		XGeLib::adsout << szPrmpt << _T("<") << (LPCTSTR)sDist << _T(">:");
		ads_initget(nBitFlag, NULL);

		return ads_getdist(NULL, _T(""), &r);
	}
	
	inline int XGetDist(ads_point ptRef, const TCHAR *szPrmpt, ads_real &r, int nBitFlag = 0)
	{
		XString sDist = XExport::Dist2Str(r);
		XGeLib::adsout << szPrmpt << _T("<") << (LPCTSTR)sDist << _T(">:");
		ads_initget(nBitFlag, NULL);
		
		return ads_getdist(ptRef, _T(""), &r);
	}
	
	inline XString LayerId2String(AcDbObjectId id)
	{
		XString sName;
		if (id.isValid())
		{
			sName = XExport::GetSymbolName(id);
		}

		if (!sName)
		{
			sName = _T("0");
		}

		return sName;
	}

	inline AcDbObjectId LayerString2Id(const TCHAR *psz, AcDbDatabase *pDb = NULL)
	{
		AcDbObjectId id;
		if (psz && _tcscmp(psz, _T("0")) != 0)
		{
			id = GetLayerIdFromString(psz, pDb);
		}

		return id;
	}

	inline Acad::ErrorStatus ReadString(AcDbDwgFiler *pFiler, XString &sResult)
	{
		TCHAR *pBuffer = NULL;
		pFiler->readString(&pBuffer);
	
		//assert(pBuffer);
		if (pBuffer == NULL)
		{
			sResult = _T("");
		}
		else
		{
			sResult = pBuffer;
			acdbFree(pBuffer);
		}
		
		return Acad::eOk;
	}

	inline COLORREF GetAcadBackColor()
	{
		AcColorSettings setAcadColor;
		acedGetCurrentColors(&setAcadColor);

		return setAcadColor.dwGfxModelBkColor;
	}

	inline int GetReal(const TCHAR *szPrmpt, ads_real &r, int nBitFlag = 0)
	{
		XGeLib::adsout << szPrmpt << _T("<") << r <<_T(">:");
		ads_initget(nBitFlag, NULL);
		
		return ads_getreal(_T(""), &r);
	}

	inline int Release(Groups *pList)
	{
		return ads_relrb((struct resbuf*)pList);
	}

	inline XPoint Ucs2Wcs(XPoint ptSrc, BOOL bVector = FALSE)
	{
		XPoint ptDest;
		Groups g1(1), g0(0);
		ads_trans(ptSrc, (resbuf *)&g1, (resbuf *)&g0, bVector, ptDest);
		return ptDest;
	}

	inline XPoint Wcs2Ucs(XPoint ptSrc, BOOL bVector = FALSE)
	{
		XPoint ptDest;
		Groups g1(1), g0(0);
		ads_trans(ptSrc, (resbuf *)&g0, (resbuf *)&g1, bVector, ptDest);
		
		return ptDest;
	}

	inline XPoint Ecs2Wcs(XPoint ptSrc, XVector3D vtEcs, BOOL bVector = FALSE)
	{
		XPoint ptDest;
		Groups gv(vtEcs), g0(0);
		ads_trans(ptSrc, (resbuf *)&gv, (resbuf *)&g0, bVector, ptDest);
		
		return ptDest;
	}

	inline XPoint Wcs2Ecs(XPoint ptSrc, XVector3D vtEcs, BOOL bVector = FALSE)
	{
		XPoint ptDest;
		Groups gv(vtEcs), g0(0);
		ads_trans(ptSrc, (resbuf *)&g0, (resbuf *)&gv, bVector, ptDest);
		
		return ptDest;
	}

	inline XPoint Ucs2Ecs(XPoint ptSrc, XVector3D vtEcs, BOOL bVector = FALSE)
	{
		XPoint ptDest;
		Groups gv(vtEcs), g1(1);
		ads_trans(ptSrc, (resbuf *)&g1, (resbuf *)&gv, bVector, ptDest);
		
		return ptDest;
	}

	inline XPoint Ecs2Ucs(XPoint ptSrc, XVector3D vtEcs, BOOL bVector = FALSE)
	{
		XPoint ptDest;
		Groups gv(vtEcs), g1(1);
		ads_trans(ptSrc, (resbuf *)&gv, (resbuf *)&g1, bVector, ptDest);
		
		return ptDest;
	}

	inline double Ucs2Wcs(double nAng)
	{
		XVector3D vtUcs(cos(nAng), sin(nAng));
		XVector3D vtWcs = Ucs2Wcs(vtUcs, TRUE);
		
		return ads_angle(XPoint(), vtWcs);
	}

	// 点进行矩阵变换
	// 参数：pt:被变换点
	//       newpt:变换结果
	//		 xform:几何变换矩阵
	inline void AT_xformpt(ads_matrix xform,ads_point pt,ads_point newpt)
	{
		int i,j;
		ads_point pt0;

		newpt[X] = newpt[Y] = newpt[Z] = 0.0;
		Cpoint(pt0, pt);

		for (i = X; i <= Z; i++) 
		{
			for (j = X; j <= Z; j++)
			{
				newpt[i] += xform[i][j] * pt0[j];
			}

			newpt[i] += xform[i][T];
		}
	}
	inline double Wcs2Ucs(double nAng)
	{
		XVector3D vtWcs(cos(nAng), sin(nAng));
		XVector3D vtUcs = Wcs2Ucs(vtWcs, TRUE);
		
		return ads_angle(XPoint(), vtUcs);
	}
	
	inline void UcsWorld()
	{
		SHads_command(RTSTR, _T("UCS"), RTSTR, _T(""), RTNONE);
	}

	inline void AsureWCS()
	{
		if(!IsWCS())
		{
			UcsWorld();
		}
	}


	inline void Refresh_DIST_SNAP()
	{
		XGeLib::_DIST_SNAP = XGeLib::_distSnap * _UNIT_SCALE;
	}

	inline AcGeMatrix3d & AsAcGeMatrix3d(ads_matrix mat)
	{
		void *p = mat;
		return *(AcGeMatrix3d *)p;
	}

	inline void AsAdsMatrix(const AcGeMatrix3d &mat1, ads_matrix mat2)
	{
		memcpy(mat2, &mat1, sizeof(ads_matrix));
	}

	inline double Rad2Degree(double nRad)
	{
		return (180.0 * nRad / PI);
	}
	
	inline double Degree2Rad(double nDeg)
	{
		return (nDeg * PI / 180.0);
	}



	inline BOOL Equal(double val1, double val2, double nSnap)
	{
		return (fabs(val1 - val2) < nSnap);
	}

	inline BOOL GreatEqual(double val1, double val2, double nSnap = XGeLib::_DIST_SNAP)
	{
		BOOL bRet = (Equal(val1, val2, nSnap) || val1 > val2);
		return bRet;
	}
	
	inline BOOL LessEqual(double val1, double val2, double nSnap = XGeLib::_DIST_SNAP)
	{
		BOOL bRet = (Equal(val1, val2, nSnap) || val1 < val2);
		return bRet;
	}
	
	inline BOOL LessThan(double val1, double val2, double nSnap = XGeLib::_DIST_SNAP)
	{
		return (val1 < val2 && !Equal(val1, val2, nSnap));
	}
	
	inline double CalArea3p(const ads_point pt1, const ads_point pt2, const ads_point pt3)
	{
		ads_real l, l1, l2, l3;
		
		l1 = ads_distance(pt1,pt2);
		l2 = ads_distance(pt2,pt3);
		l3 = ads_distance(pt3,pt1);
		l = (l1 + l2 + l3) / 2.0;
		
		return sqrt(fabs(l * (l - l1) * (l - l2) * (l - l3)));
	}

	inline BOOL GreatThan(double val1, double val2,  double nSnap = XGeLib::_DIST_SNAP)
	{
		return (val1 > val2 && !Equal(val1, val2, nSnap));
	}

	inline BOOL IsMirrorMatrix(ads_matrix mat)
	{
		XPoint ptOrg, ptX(1000, 0), ptY(0, 1000);
		ptOrg.TransformBy(mat);
		ptX.TransformBy(mat);
		ptY.TransformBy(mat);
	
		double nAng = XExport::CT_std_angle(ads_angle(ptOrg, ptY) - ads_angle(ptOrg, ptX));
		return (fabs(nAng - PI * 1.5) < XGeLib::_angSnap);
	}

	inline BOOL IsMirrorMatrix(const AcGeMatrix3d &mat)
	{
		XPoint ptOrg, ptX(1000, 0), ptY(0, 1000);
		ptOrg.TransformBy(mat);
		ptX.TransformBy(mat);
		ptY.TransformBy(mat);
		
		double nAng = XExport::CT_std_angle(ads_angle(ptOrg, ptY) - ads_angle(ptOrg, ptX));
		return (fabs(nAng - PI * 1.5) < XGeLib::_angSnap);
	}

	inline ads_real operator & (const XVector3D & pt1, const XVector3D & pt2)
	{
		return pt1.x * pt2.x + pt2.y * pt1.y + pt1.z * pt2.z;
	}

	inline XVector3D operator * (const XVector3D &pt1, const Vector3D &pt2)
	{
		XVector3D vt;
		vt.x = pt1.y * pt2.z - pt1.z * pt2.y;
		vt.y = pt1.z * pt2.x - pt1.x * pt2.z;
		vt.z = pt1.x * pt2.y - pt1.y * pt2.x;
		
		return vt;
	}

	inline void SubPoint(ads_point dest, ads_point src)
	{
		Spoint(dest, dest[0] - src[0], dest[1] - src[1], dest[2] - src[2]);
	}
	
	inline void AddPoint(ads_point dest, ads_point src)
	{
		Spoint(dest, dest[0] + src[0], dest[1] + src[1], dest[2] + src[2]);
	}

	template <class K>
	int xg_putsym(const TCHAR *sym, K val)
	{
		Groups g(val);
		return ads_putsym(sym, (resbuf *)&g);
	}
	
	//将弧度规范到[0,2PI)
	//NA(angle) = NA(angle+n*PI2) = NA(angle-n*PI2);
	inline double NA(double angle)
	{
		if (UP_ZEROA(angle))
		{
			double da = angle - PI2;
			if (DOWN_ZEROA(da))
			{
				return angle;
			}
			else if (UP_ZEROA(da))
			{
				return NA(da);
			}
			else
			{
				return 0;
			}
		}
		else if (DOWN_ZEROA(angle))
		{
			return NA(angle + PI2);
		}
		else
		{
			return 0;
		}
	}

	//转化为反向角度坐标系中角度[0,2PI)
	inline double RA(double a)
	{
		return NA(-a);
	}
	
	//从起始角到终止角的角度,[0,2PI),很接近的角度将返回0!
	inline double ALEN(double startAngle,double endAngle)
	{
		return NA(endAngle - startAngle);
	}

	//角度包含判断，与端角很接近时将返回true,angleLen>=0!
	inline bool AIN(double a,double startAngle,double angleLen)
	{
		return DOWNEQUAL_ZEROA(ALEN(startAngle,a) - angleLen);
	}

	// 把一角度变为允许标注的角度值(1,4象限即0~PI/2.0或 3*PI/2.0~0)
	inline double xg_angle(double dAngle)
	{
		double dang1 = 0.0;
		double dSnap = PI / 180.0; //1度
		dang1 = XExport::CT_std_angle(dAngle);
		
		if (GreatThan(dang1, PI/2.0, dSnap) && LessThan(dang1, PI, dSnap))
		{
			dang1 += PI;
		}
		else if (GreatEqual(dang1, PI, dSnap) && LessEqual(dang1, PI*1.5, dSnap))
		{
			dang1 -= PI;
		}
		return dang1;
	}
	
	// 向量的点积
	inline ads_real CT_VectorDotPlus(ads_vector pt1, ads_vector pt2)
	{
		ads_real result;
		result = pt1[0] * pt2[1] + pt2[1] * pt1[1] + pt1[2] * pt2[2];
		return result;
	}

	//快速判断两点是否重合
	inline BOOL IsEqual(const AcGePoint3d pt1, const AcGePoint3d pt2,double tol = TOL)
	{
		if (fabs(pt1.x - pt2.x) < tol && fabs(pt1.y - pt2.y) < tol && fabs(pt1.z - pt2.z) < tol) 
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}

	//将点PT从ADS格式转换成ARX格式
	inline void Ads2ARXPt(const ads_point pt,AcGePoint3d& retPt)
	{
		retPt[X] = pt[X];
		retPt[Y] = pt[Y];
		retPt[Z] = pt[Z];
	}
	
	//将点PT从ARX格式转换成ADS格式
	inline void ARX2AdsPt(const AcGePoint3d pt,ads_point retPt)
	{
		retPt[X] = pt[X];
		retPt[Y] = pt[Y];
		retPt[Z] = pt[Z];
	}
	
	//计算pt1与pt2决定的直线与X轴的夹角
	inline double AngleToX(AcGePoint3d& pt1,AcGePoint3d& pt2)
	{
		ads_point ads_pt1,ads_pt2;
		ARX2AdsPt(pt1,ads_pt1);
		ARX2AdsPt(pt2,ads_pt2);
		return acutAngle(ads_pt1,ads_pt2);
	}
	
	// 由系统的显示模式和构件的显示类型确定显示方式 
	//0--NONE; 1--2D; 2--3D; 3--2D&3D;
	inline int GetDispMethod(int nDrawMode, int nDrawType)
	{
		return nDrawMode;
	}

	//pt是否在pt11-pt12所在线段上	
	inline BOOL IsOnLineSeg(AcGePoint3d pt11,AcGePoint3d pt12,AcGePoint3d pt,double tol = TOL)
	{
		AcGeTol tol1;
		tol1.setEqualPoint(tol);
		
		AcGeLineSeg3d line(pt11,pt12);
		if (line.isOn(pt,tol1)) 
		{
			return 1;
		}
		else 
		{
			return 0;
		}
	}
	
	inline AcGePoint3d polar(AcGePoint3d& pt0,double ang,double dist)
	{
		AcGePoint3d pt3d;
		ads_point ads_pt,ads_ret;
		ARX2AdsPt(pt0,ads_pt);
		
		acutPolar(ads_pt,ang,dist,ads_ret);
		Ads2ARXPt(ads_ret,pt3d);
		
		return pt3d;
	}
	
	template <class K>
	inline int Compare(K n1, K n2)
	{
		if (n1 > n2)
		{
			return 1;
		}
		else if (n1 < n2)
		{
			return -1;
		}
		else
		{
			return 0;
		}
	}

	template<class T> inline void Exchange(T& t1,T&t2)
	{
		T temp = t1;
		t1 = t2;
		t2 = temp;
	}	

	template<class T> inline T Min2(T t1,T t2)
	{
		return t2 < t1 ? t2:t1;
	}
	
	template<class T> inline T Max2(T t1,T t2)
	{
		return t2 > t1 ? t2 : t1;
	}
};

using namespace XPrivate;

#endif