4635 lines
99 KiB
C++
4635 lines
99 KiB
C++
/*-----------------------------------------------------
|
||
//内部二维几何计算辅助,不可以导出
|
||
------------------------------------------------------*/
|
||
|
||
#ifndef __GEOM_H__
|
||
#define __GEOM_H__
|
||
|
||
#ifdef XGEEXP
|
||
#define XGEAPI
|
||
#else
|
||
#define XGEAPI
|
||
#endif
|
||
|
||
#define EX_INT 11000
|
||
#define EX_REAL 11100
|
||
#define EX_STRING 11200
|
||
#define EX_HANDLE 11300
|
||
#define EX_STRUCT 11400
|
||
#define EX_END 11500
|
||
|
||
#define EX_NEW 20000
|
||
#define EX_BIND 20000
|
||
|
||
#define TOL 0.0001
|
||
#define fTOL 1.e-8
|
||
|
||
#define XD_SHORT 1070
|
||
|
||
#ifndef __XDATA_H
|
||
#define XD_STR 1000
|
||
#define XD_REAL 1040
|
||
#define XD_LONG 1071
|
||
#define XD_POINT 1010
|
||
#define XD_HANDLE 1005
|
||
#endif
|
||
|
||
#define SS_CREATE 0x01
|
||
#define SS_FREE 0x02
|
||
#define SS_MARK 0x04
|
||
|
||
#define Q_YES 1
|
||
#define Q_NO 0
|
||
|
||
#define LAYSTAT_ON 0x01
|
||
#define LAYSTAT_OFF 0x02
|
||
#define LAYSTAT_THAW 0x04
|
||
#define LAYSTAT_FREEZE 0x08
|
||
#define LAYSTAT_UNLOCK 0x10
|
||
#define LAYSTAT_LOCK 0x20
|
||
#define LAYSTAT_CURRENT 0x40
|
||
|
||
#define RTSTRUCT 5011
|
||
|
||
#define XD_INT 1070
|
||
#define XD_REAL 1040
|
||
#define XD_POINT 1010
|
||
#define XD_STR 1000
|
||
#define XD_HANDLE 1005
|
||
|
||
#define MXYZ 0
|
||
#define SXYZ 1
|
||
#define RX 2
|
||
#define RY 3
|
||
#define RZ 4
|
||
#define NOP 5
|
||
#define EXIT 6
|
||
|
||
#define OFFSET_LEFT 0
|
||
#define OFFSET_RIGHT 1
|
||
|
||
#define LS_FINITE 1
|
||
#define LS_INFINITE 0
|
||
|
||
#define PR_OUTSIDE 0
|
||
#define PR_ONPT1 1
|
||
#define PR_ONCIRCLE 1
|
||
#define PR_ONPT2 2
|
||
#define PR_INSIDE 3
|
||
#define PR_EXTEND 4
|
||
#define PR_EDGE 5
|
||
#define PR_INTERS 6
|
||
|
||
#define OS_NON 0
|
||
#define OS_END 1
|
||
#define OS_MID 2
|
||
#define OS_CEN 4
|
||
#define OS_NOD 8
|
||
#define OS_QUA 16
|
||
#define OS_INT 32
|
||
#define OS_INS 64
|
||
#define OS_PER 128
|
||
#define OS_TAN 256
|
||
#define OS_NEA 512
|
||
#define OS_QUI 1024
|
||
#define OS_APP 2048
|
||
|
||
#define XD_INT 1070
|
||
#define XD_REAL 1040
|
||
#define XD_POINT 1010
|
||
#define XD_STR 1000
|
||
#define XD_HANDLE 1005
|
||
|
||
#ifndef PI
|
||
#define PI 3.1415926535897932384626433832795
|
||
#endif
|
||
|
||
#define DPI 0.017453292519943295
|
||
#define PIDD 57.295779513082323
|
||
#define PI2 6.2831853071796
|
||
|
||
#define LINE_SEGMENT (RTNORM + 1)
|
||
#define ARC_SEGMENT (RTNORM + 2)
|
||
|
||
#define SIDE1_INVISIBLE 0x01
|
||
#define SIDE2_INVISIBLE 0x02
|
||
#define SIDE3_INVISIBLE 0x04
|
||
|
||
#ifndef UNIT_SCALE
|
||
#define UNIT_SCALE 1.0
|
||
#endif
|
||
|
||
#define PRIV_STR(s) s
|
||
|
||
#define CMF_SHOWSHAPE 0x01
|
||
#define CMF_NO2D 0x02
|
||
#define CMF_NO3D 0x04
|
||
#define CMF_DIVIDE2D 0x08//TArch7用于二维散水
|
||
|
||
#define ELEMENTS(array) (sizeof(array) / sizeof((array)[0]))
|
||
#define Spoint(pt, x, y, z) {pt[0] = (x); pt[1] = (y); pt[2] = (z);}
|
||
#define Cpoint(to, from) {to[0] = from[0]; to[1] = from[1]; to[2] = from[2];}
|
||
|
||
#define Midpoint(p1, p2, dest) \
|
||
{ \
|
||
dest[0] = (p1[0] + p2[0]) / 2.0; \
|
||
dest[1] = (p1[1] + p2[1]) / 2.0; \
|
||
dest[2] = (p1[2] + p2[2]) / 2.0; \
|
||
}
|
||
|
||
#define MAX_MIN(mn, type) \
|
||
{ \
|
||
va_list vlst; \
|
||
va_start(vlst, r1); \
|
||
type res = r1; \
|
||
for(int i = 0; i < n-1; i++) { \
|
||
type r = va_arg(vlst, type); \
|
||
res = mn(res, r); \
|
||
} \
|
||
va_end(vlst); \
|
||
return res; \
|
||
}
|
||
|
||
#define NOT_FOUND -1
|
||
|
||
extern double _distSnap/* = 0.001;*/;
|
||
extern double _angSnap/* = 0.001;*/;
|
||
extern double _DIST_SNAP/* = 0.001;*/;
|
||
extern double g_nCirDeviation/* = 40*/;
|
||
|
||
namespace XGE
|
||
{
|
||
const Adesk::UInt16 kColorByLayer = 256;
|
||
|
||
enum FormatType
|
||
{
|
||
WS_CHAR,
|
||
WS_INT,
|
||
WS_DOUBLE,
|
||
WS_STRING,
|
||
WS_FORMAT
|
||
};
|
||
|
||
enum CurveType
|
||
{
|
||
CURVE_LINE,
|
||
CURVE_ARC,
|
||
CURVE_CIRCLE
|
||
};
|
||
|
||
enum ShapeType
|
||
{
|
||
SHAPE_UNKNOWN,
|
||
SHAPE_CIRCLE,
|
||
SHAPE_RECTANGLE,
|
||
SHAPE_POLY
|
||
};
|
||
|
||
//线段类型
|
||
enum BLType
|
||
{
|
||
BLINESEG, //直线段
|
||
BARCSEG //圆弧段
|
||
};
|
||
|
||
enum HitTestPos
|
||
{
|
||
POS_Error = 0, //错误
|
||
POS_Left = 1, //左边
|
||
POS_Rigth = 2, //右边
|
||
POS_Start = 3, //起始点
|
||
POS_End = 4, //终止点
|
||
POS_InLine = 5, //线内
|
||
POS_StartLineEx = 6, //起始侧延长线
|
||
POS_EndLineEx = 7 //终止侧延长线
|
||
};
|
||
|
||
typedef struct Binary
|
||
{
|
||
short length;
|
||
char *buffer;
|
||
}*STBINARY,*PSTBINARY;
|
||
|
||
class XGEAPI XPushPrec {
|
||
public:
|
||
ads_real oldDistSnap, oldAngSnap;
|
||
XPushPrec(ads_real dist, ads_real ang):oldDistSnap(_distSnap), oldAngSnap(_angSnap) {
|
||
_distSnap=dist, _angSnap=ang;
|
||
}
|
||
~XPushPrec() {_distSnap=oldDistSnap; _angSnap=oldAngSnap; }
|
||
};
|
||
|
||
class XGEAPI Groups
|
||
{
|
||
public:
|
||
Groups(int i=0);
|
||
Groups(ads_real r);
|
||
Groups(const ads_point p);
|
||
Groups(LPCTSTR s);
|
||
Groups(ads_name n);
|
||
Groups(long l);
|
||
|
||
Groups(const Groups& src);
|
||
|
||
//Extend data
|
||
Groups(int, int i);
|
||
Groups(int, ads_real r);
|
||
Groups(int strOrHandle, LPCTSTR s);
|
||
|
||
~Groups();
|
||
|
||
// 重新定义 new, delete操作符, 以便与ADS兼容
|
||
void *operator new(size_t);
|
||
void operator delete(void *a);
|
||
|
||
operator resbuf & ();
|
||
operator resbuf * ();
|
||
int operator == (const Groups &other) const;
|
||
int operator != (const Groups &other) const;
|
||
Groups& operator = (const Groups &src);
|
||
|
||
public:
|
||
Groups *next;
|
||
|
||
union {
|
||
short type;
|
||
short code;
|
||
};
|
||
|
||
union {
|
||
ads_real real;
|
||
ads_point point;
|
||
HALF_PTR shortInt;
|
||
LPTSTR string;
|
||
ads_name adsName;
|
||
long longInt;
|
||
#ifdef _WIN64
|
||
LONG_PTR longPtr;
|
||
#endif
|
||
Binary binary;
|
||
};
|
||
#ifdef _WIN64
|
||
Groups(LONG_PTR val) {longPtr=val; type=RTLONG_PTR;next=NULL;};
|
||
#endif
|
||
};
|
||
|
||
typedef Groups *PGroups;
|
||
typedef Groups *PList;
|
||
|
||
|
||
inline Groups::Groups(int i)
|
||
{
|
||
shortInt = i;
|
||
type = RTSHORT;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(ads_real r)
|
||
{
|
||
real = r;
|
||
type = RTREAL;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(const ads_point p)
|
||
{
|
||
memcpy(point, p, sizeof(ads_point));
|
||
type = RT3DPOINT;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(LPCTSTR s)
|
||
{
|
||
string = _tcsdup(s);
|
||
type = RTSTR;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(ads_name n)
|
||
{
|
||
adsName[0] = n[0];
|
||
adsName[1] = n[1];
|
||
type = RTENAME;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(long l)
|
||
{
|
||
longInt = l;
|
||
type = RTLONG;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(const Groups & src)
|
||
{
|
||
*this = src;
|
||
}
|
||
|
||
inline Groups::Groups(int, int i)
|
||
{
|
||
shortInt = i;
|
||
type = XD_SHORT;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(int, ads_real r)
|
||
{
|
||
real = r;
|
||
type = XD_REAL;
|
||
next = NULL;
|
||
}
|
||
|
||
inline Groups::Groups(int strOrHandle, LPCTSTR s)
|
||
{
|
||
string = _tcsdup(s);
|
||
type = strOrHandle;
|
||
next = NULL;
|
||
}
|
||
|
||
inline void* Groups::operator new(size_t)
|
||
{
|
||
return (void *)ads_newrb(0);
|
||
}
|
||
|
||
inline void Groups::operator delete(void *a)
|
||
{
|
||
ads_relrb((resbuf *)a);
|
||
}
|
||
|
||
inline Groups::operator resbuf & ()
|
||
{
|
||
return *((resbuf *)this);
|
||
}
|
||
|
||
inline Groups::operator resbuf * ()
|
||
{
|
||
return (resbuf *)this;
|
||
}
|
||
|
||
inline int Groups::operator != (const Groups &other) const
|
||
{
|
||
return !(*this == other);
|
||
}
|
||
|
||
inline double CT_std_angle(double dAngle)
|
||
{
|
||
double dAngleTmp = dAngle;
|
||
|
||
if ( fabs(dAngleTmp - 2.0 * PI) < 1.0E-9 )
|
||
{
|
||
dAngleTmp = 0.0;
|
||
return dAngleTmp;
|
||
}
|
||
|
||
while((dAngleTmp > (PI * 2.0 + 1.0E-9)) || (dAngleTmp < -1.0E-9))
|
||
{
|
||
if (dAngleTmp < -1.0E-9)
|
||
{
|
||
dAngleTmp = dAngleTmp + 2.0 * PI;
|
||
}
|
||
else if (dAngleTmp > (PI * 2.0 + 1.0E-9))
|
||
{
|
||
dAngleTmp = dAngleTmp - 2.0 * PI;
|
||
}
|
||
}
|
||
return dAngleTmp;
|
||
}
|
||
|
||
class XGEAPI RBList
|
||
{
|
||
public:
|
||
|
||
RBList();
|
||
|
||
RBList(int,...);
|
||
|
||
RBList(const resbuf *rb);
|
||
|
||
RBList (const RBList & src);
|
||
|
||
~RBList();
|
||
|
||
operator resbuf *();
|
||
|
||
operator void * ();
|
||
|
||
int operator !() const;
|
||
|
||
void operator = (const RBList & src);
|
||
|
||
void Append(resbuf * lst);
|
||
|
||
void FreeGroups();
|
||
|
||
Groups *SearchNode(int cd) const;
|
||
|
||
int GetData (int cd,void *buf) const;
|
||
|
||
int SetData(int cd,...);
|
||
|
||
static int TypeOfCode(int code);
|
||
|
||
static PGroups VBuildList(int *parguments);
|
||
|
||
public:
|
||
|
||
PGroups groups;
|
||
|
||
protected:
|
||
#ifdef _WIN64
|
||
int _SetData(int, va_list);
|
||
#else
|
||
int _SetData(int,void *); // to support Entity::SetData & RBList::SetData;
|
||
#endif
|
||
private:
|
||
|
||
int SizeOfType(int type)const;
|
||
};
|
||
|
||
class XGEAPI SymbolTable : public RBList
|
||
{
|
||
public:
|
||
|
||
SymbolTable();
|
||
|
||
SymbolTable(SymbolTable &);
|
||
|
||
SymbolTable(LPCTSTR tblname, LPCTSTR sym, int setnext = 0);
|
||
|
||
~SymbolTable();
|
||
|
||
static resbuf *tblsearch(LPCTSTR tblname, LPCTSTR sym, int setnext = 0);
|
||
|
||
resbuf * tblnext(int rewind = 0);
|
||
|
||
protected:
|
||
|
||
TCHAR *tblName;
|
||
};
|
||
|
||
typedef class SymbolTable XSymbolTable;
|
||
|
||
typedef ads_real ads_vector[3];
|
||
typedef struct resbuf rbtype;
|
||
typedef ads_real (* MatrixPointer)[4];
|
||
|
||
typedef struct plan_para
|
||
{
|
||
double A, B, C, D;
|
||
}PLAN_PARA;
|
||
|
||
template <class R>
|
||
class Node
|
||
{
|
||
public:
|
||
|
||
Node(Node<R> *p, Node<R> *n, R* d);
|
||
~Node(){}
|
||
|
||
public:
|
||
R * data;
|
||
Node<R> * previous;
|
||
Node<R> * next;
|
||
};
|
||
|
||
template <class R>
|
||
Node<R>::Node(Node<R> *p, Node<R> *n, R* d)
|
||
{
|
||
assert(d!=NULL);
|
||
previous=p;
|
||
next = n;
|
||
data = d;
|
||
}
|
||
|
||
template <class R>
|
||
class DList
|
||
{
|
||
public:
|
||
DList(int dFlag = 1);
|
||
DList(R * addr, int nCount);
|
||
~DList();
|
||
|
||
int operator !() const;
|
||
R * operator [](int n);
|
||
const R & operator [](int n) const;
|
||
|
||
void MoveToHead();
|
||
|
||
const R & GetAt(int n) const;
|
||
R * GetAt(int n);
|
||
|
||
//并入
|
||
DList<R>& operator << (DList<R>&listother);
|
||
|
||
//复制
|
||
DList<R>& copyFrom(const DList<R>& listother);
|
||
|
||
void Insert(R * node);
|
||
void Append(R * node);
|
||
void Replace(R * node, int n = -1);
|
||
void Reset();
|
||
|
||
int Remove();
|
||
int Remove(int n);
|
||
|
||
// 求当前指针的位置(-1: current 为 NULL)
|
||
int CurPosition() const;
|
||
|
||
int Length() const;
|
||
|
||
int GetDelFlag() const;
|
||
void SetDelFlag(int nFlag);
|
||
|
||
R * CurData() const;
|
||
void SetCurData(R* p);
|
||
|
||
int Find(const R * node);
|
||
int Exist(const R * node) const;
|
||
|
||
// 把指针移到最后,准备下一个插入
|
||
void MoveEnd();
|
||
|
||
R* Head() const;
|
||
R* Tail() const;
|
||
R* FindNode(const void *, int (*cmp)(const R *, const void *));
|
||
|
||
void QuickSort(int (*cmp)(const R *, const R *));
|
||
void Swap(int n1,int n2);
|
||
void Reverse();
|
||
void FindAndDel(const void *p, int (*cmp)(const R *, const void *));
|
||
|
||
private:
|
||
int m_nLen, m_nCurIndex;
|
||
Node<R>* m_pCurrent;
|
||
|
||
protected:
|
||
int m_nDelFlag;
|
||
Node<R>* head;
|
||
Node<R>* tail;
|
||
|
||
virtual int Compare(const R *, const R *) const;
|
||
|
||
private:
|
||
DList<R> & operator = (const DList<R> &src);
|
||
DList(const DList<R> &src);
|
||
};
|
||
|
||
template <class R>
|
||
DList<R>::DList(const DList<R> &src)
|
||
{
|
||
m_nDelFlag = src.m_nDelFlag;
|
||
for (int i = 0;i < src.Length();i++)
|
||
{
|
||
Append(new R( src[i] ) );
|
||
}
|
||
}
|
||
|
||
template <class R>
|
||
inline DList<R>::DList(int nFlag)
|
||
{
|
||
head = tail = m_pCurrent = NULL;
|
||
m_nDelFlag = nFlag;
|
||
m_nCurIndex = 0;
|
||
m_nLen = 0;
|
||
}
|
||
|
||
template <class R>
|
||
DList<R>::DList( R *pBeg, int nCount) : head(NULL), tail(NULL), m_pCurrent(NULL), m_nDelFlag(1), m_nCurIndex(0), m_nLen(0)
|
||
{
|
||
R *p = pBeg;
|
||
for (int i = 0; i < nCount; i++)
|
||
{
|
||
Append(new R(*p));
|
||
p++;
|
||
}
|
||
}
|
||
|
||
// 缺省方式下: R的分配和释放是由用户负责
|
||
template <class R> class DStack: public DList<R> {
|
||
public:
|
||
DStack() : DList<R> (0) {}
|
||
void Push(R *dat) {
|
||
this->MoveEnd();
|
||
this->Insert(dat);
|
||
// current=tail;
|
||
}
|
||
R * Pop() { // Use Tail() to get the Stack top
|
||
//current=tail;
|
||
R * res = this->Tail(); //CurData();
|
||
if(this->Length()) this->Remove(this->Length()-1);
|
||
// current=tail;
|
||
return res;
|
||
}
|
||
R * Top() { return this->Tail(); }
|
||
};
|
||
|
||
template <class R>
|
||
DList<R>::~DList()
|
||
{
|
||
Node<R> *p = head, *p1 = NULL;
|
||
while(p)
|
||
{
|
||
p1 = p->next;
|
||
if (m_nDelFlag)
|
||
{
|
||
if (p->data != NULL)
|
||
{
|
||
delete p->data;
|
||
}
|
||
}
|
||
delete p;
|
||
p = p1;
|
||
}
|
||
}
|
||
|
||
template <class R>
|
||
inline void DList<R>::Append(R * node)
|
||
{
|
||
m_pCurrent = NULL;
|
||
m_nCurIndex = m_nLen;
|
||
Insert(node);
|
||
}
|
||
|
||
template <class R>
|
||
inline void DList<R>::Replace(R * node, int n)
|
||
{
|
||
if (n >= 0)
|
||
{
|
||
(*this)[n];
|
||
}
|
||
|
||
if (m_pCurrent)
|
||
{
|
||
if (m_nDelFlag)
|
||
{
|
||
if (m_pCurrent->data != NULL)
|
||
{
|
||
delete m_pCurrent->data;
|
||
}
|
||
}
|
||
m_pCurrent->data = node;
|
||
}
|
||
}
|
||
|
||
template <class R>
|
||
inline int DList<R>::Remove(int n)
|
||
{
|
||
(*this)[n];
|
||
return Remove();
|
||
}
|
||
|
||
template <class R>
|
||
inline int DList<R>::CurPosition() const
|
||
{
|
||
return m_nCurIndex<m_nLen ? m_nCurIndex : -1;
|
||
}
|
||
|
||
template <class R>
|
||
inline int DList<R>::Length() const
|
||
{
|
||
return m_nLen;
|
||
}
|
||
|
||
template <class R>
|
||
inline void DList<R>::SetDelFlag(int nFlag)
|
||
{
|
||
m_nDelFlag = nFlag;
|
||
}
|
||
|
||
template <class R>
|
||
inline int DList<R>::GetDelFlag() const
|
||
{
|
||
return m_nDelFlag;
|
||
}
|
||
|
||
template <class R>
|
||
inline int DList<R>::operator !() const
|
||
{
|
||
if (head)
|
||
{
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
template <class R>
|
||
inline const R & DList<R>::operator [](int n) const
|
||
{
|
||
DList<R> *pThis = (DList<R> *)this;
|
||
const R * pData = (*pThis)[n];
|
||
return *pData;
|
||
}
|
||
|
||
template <class R>
|
||
inline void DList<R>::MoveToHead()
|
||
{
|
||
m_pCurrent = head;
|
||
m_nCurIndex = 0;
|
||
}
|
||
|
||
// 移到当前指针到第 n 个节点, 并返回它
|
||
// 假如 n<0, exit; ||则移到倒数第 n个节点
|
||
template <class R>
|
||
inline R * DList<R>::operator [](int n)
|
||
{
|
||
int i = 0;
|
||
if (n >= 0 && n < m_nLen)
|
||
{
|
||
if (!m_pCurrent)
|
||
{
|
||
m_pCurrent=head;
|
||
m_nCurIndex=0;
|
||
}
|
||
|
||
int diff = n - m_nCurIndex;
|
||
if (diff >= 0)
|
||
{
|
||
if (m_nCurIndex == 0 && n == m_nLen - 1)
|
||
{
|
||
m_pCurrent=tail;
|
||
m_nCurIndex=m_nLen - 1;
|
||
}
|
||
else
|
||
{
|
||
for (i = 0; i < diff; i++)
|
||
{
|
||
assert(m_pCurrent != NULL);
|
||
m_pCurrent = m_pCurrent->next;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (m_nCurIndex == m_nLen - 1 && n == 0)
|
||
{
|
||
m_pCurrent=head;
|
||
m_nCurIndex=0;
|
||
}
|
||
else
|
||
{
|
||
for (i = 0; i < -diff; i++)
|
||
{
|
||
assert(m_pCurrent != NULL);
|
||
m_pCurrent = m_pCurrent->previous;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
assert(0);
|
||
}
|
||
m_nCurIndex = n;
|
||
|
||
if (m_pCurrent)
|
||
{
|
||
return m_pCurrent->data;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
template <class R>
|
||
inline const R & DList<R>::GetAt(int n) const
|
||
{
|
||
DList<R> *pThis = (DList<R> *)this;
|
||
const R * pData = (*pThis).GetAt(n);
|
||
return *pData;
|
||
}
|
||
|
||
// 移到当前指针到第 n 个节点, 并返回它
|
||
// 假如 n<0, exit; ||则移到倒数第 n个节点
|
||
template <class R>
|
||
inline R * DList<R>::GetAt(int n)
|
||
{
|
||
int i = 0;
|
||
if (n >= 0 && n < m_nLen)
|
||
{
|
||
if (!m_pCurrent)
|
||
{
|
||
m_pCurrent=head;
|
||
m_nCurIndex=0;
|
||
}
|
||
|
||
int diff = n - m_nCurIndex;
|
||
if (diff >= 0)
|
||
{
|
||
for (i = 0; i < diff; i++)
|
||
{
|
||
assert(m_pCurrent != NULL);
|
||
m_pCurrent = m_pCurrent->next;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (m_nCurIndex == m_nLen - 1 && n == 0)
|
||
{
|
||
m_pCurrent=head;
|
||
m_nCurIndex=0;
|
||
}
|
||
else
|
||
{
|
||
for (i = 0; i < -diff; i++)
|
||
{
|
||
assert(m_pCurrent != NULL);
|
||
m_pCurrent = m_pCurrent->previous;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
assert(0);
|
||
}
|
||
m_nCurIndex = n;
|
||
|
||
if (m_pCurrent)
|
||
{
|
||
return m_pCurrent->data;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
template <class R>
|
||
inline R * DList<R>::CurData() const
|
||
{
|
||
return m_pCurrent ? m_pCurrent->data : NULL;
|
||
}
|
||
|
||
template <class R>
|
||
inline void DList<R>::SetCurData(R* p)
|
||
{
|
||
if (m_pCurrent != NULL)
|
||
{
|
||
m_pCurrent->data = p;
|
||
}
|
||
}
|
||
|
||
template <class R>
|
||
inline void DList<R>::MoveEnd()
|
||
{
|
||
m_nCurIndex = -1;
|
||
m_pCurrent = NULL;
|
||
}
|
||
|
||
template <class R>
|
||
inline R* DList<R>::Head() const
|
||
{
|
||
if (head)
|
||
{
|
||
return head->data;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
template <class R>
|
||
inline R* DList<R>::Tail() const
|
||
{
|
||
if (tail)
|
||
{
|
||
return tail->data;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
template <class R>
|
||
inline void DList<R>::FindAndDel(const void *p, int (*cmp)(const R *, const void *))
|
||
{
|
||
while(FindNode(p,cmp) != NULL)
|
||
{
|
||
Remove();
|
||
}
|
||
}
|
||
|
||
//并入链表，list被直接连接到this链表的末尾，成为this链表的一部分
|
||
//最后this链表的游标值不变,而list变为Reset状态
|
||
template <class R>
|
||
DList<R>& DList<R>::operator << (DList<R> &listother)
|
||
{
|
||
if (listother.Length() == 0)
|
||
{
|
||
return *this;
|
||
}
|
||
|
||
if (Length() > 0)
|
||
{
|
||
tail->next = listother.head;
|
||
listother.head->previous = tail;
|
||
}
|
||
else
|
||
{
|
||
head = listother.head;
|
||
}
|
||
|
||
//new tail
|
||
tail = listother.tail;
|
||
|
||
//increase length
|
||
m_nLen += listother.Length();
|
||
|
||
//reset list
|
||
listother.head = listother.tail = listother.m_pCurrent = NULL;
|
||
listother.m_nLen = listother.m_nCurIndex = 0;
|
||
|
||
return *this;
|
||
}
|
||
|
||
template <class R>
|
||
DList<R>& DList<R>::copyFrom(const DList<R>& listother)
|
||
{
|
||
m_nDelFlag = listother.m_nDelFlag;
|
||
if (this != &listother)
|
||
{
|
||
Reset();
|
||
for (int i = 0;i < listother.Length();i++)
|
||
{
|
||
Append(new R( listother[i] ) );
|
||
}
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
template <class R>
|
||
inline DList<R> & DList<R>::operator = (const DList<R> &src)
|
||
{
|
||
return copyFrom(src);
|
||
}
|
||
|
||
|
||
// 重新初始化
|
||
template <class R>
|
||
void DList<R>::Reset()
|
||
{
|
||
Node<R> *p = head, *p1 = NULL;
|
||
while(p)
|
||
{
|
||
p1 = p->next;
|
||
if (m_nDelFlag)
|
||
{
|
||
if (p->data != NULL)
|
||
{
|
||
delete p->data;
|
||
}
|
||
}
|
||
delete p;
|
||
p = p1;
|
||
}
|
||
head = tail = m_pCurrent = NULL;
|
||
m_nLen = 0; m_nCurIndex = 0;
|
||
}
|
||
|
||
template <class R>
|
||
int DList<R>::Exist(const R * node) const
|
||
{
|
||
for (Node<R> *p = head; p != NULL; p = p->next)
|
||
{
|
||
if (Compare(p->data, node) == 0)
|
||
{
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
template <class R>
|
||
int DList<R>::Find(const R * node)
|
||
{
|
||
for (m_nCurIndex = 0; m_nCurIndex < m_nLen; m_nCurIndex++)
|
||
{
|
||
if (Compare((*this)[m_nCurIndex], node) == 0)
|
||
{
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
template <class R>
|
||
inline int DList<R>::Compare(const R * node1, const R *node2) const
|
||
{
|
||
if (node1 == node2)
|
||
{
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
// 删除当前节点
|
||
template <class R>
|
||
int DList<R>::Remove()
|
||
{
|
||
if (!m_pCurrent)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
Node<R> *p, *n;
|
||
p = m_pCurrent->previous;
|
||
n = m_pCurrent->next;
|
||
if (m_pCurrent == head)
|
||
{ //删除头节点
|
||
if (m_nDelFlag)
|
||
{
|
||
if (m_pCurrent->data != NULL)
|
||
{
|
||
delete m_pCurrent->data;
|
||
}
|
||
}
|
||
delete m_pCurrent;
|
||
head = m_pCurrent = n;
|
||
if (!n)
|
||
{
|
||
tail = NULL;
|
||
}
|
||
if (n)
|
||
{
|
||
n->previous = NULL;
|
||
}
|
||
}
|
||
else if (p)
|
||
{ // 当前节点变为下一个节点
|
||
if (m_nDelFlag)
|
||
{
|
||
if (m_pCurrent->data != NULL)
|
||
{
|
||
delete m_pCurrent->data;
|
||
}
|
||
}
|
||
delete m_pCurrent;
|
||
p->next = n;
|
||
if (n)
|
||
{
|
||
n->previous = p;
|
||
}
|
||
else
|
||
{
|
||
tail = p; //删除尾节点
|
||
}
|
||
m_pCurrent = n;
|
||
}
|
||
else
|
||
{
|
||
assert(0);
|
||
}
|
||
m_nLen--;
|
||
return 1;
|
||
}
|
||
|
||
// 在当前节点之前增加
|
||
template <class R>
|
||
void DList<R>::Insert( R *dat)
|
||
{
|
||
assert(dat != NULL);
|
||
|
||
if (head == NULL)
|
||
{
|
||
head = tail = new Node<R> (NULL, NULL, dat);
|
||
assert(head != NULL);
|
||
m_pCurrent = NULL; //缺省插入尾部
|
||
}
|
||
else if (m_pCurrent == NULL)
|
||
{ //加到尾部
|
||
Node<R> *tmp =new Node<R> (tail, NULL, dat);
|
||
assert(tmp != NULL);
|
||
tail->next = tmp;
|
||
tail = tmp;
|
||
}
|
||
else if (m_pCurrent->previous)
|
||
{ //插入中间
|
||
Node<R> *p = m_pCurrent->previous;
|
||
p->next = m_pCurrent->previous = new Node<R> (p,m_pCurrent,dat);
|
||
assert(p->next != NULL);
|
||
}
|
||
else if (m_pCurrent == head)
|
||
{ // 加到表头前 curren == head
|
||
head = new Node<R> (NULL, m_pCurrent, dat);
|
||
assert(head != NULL);
|
||
m_pCurrent->previous = head;
|
||
}
|
||
m_nLen++;
|
||
m_nCurIndex++;
|
||
}
|
||
|
||
template <class R>
|
||
void DList<R>::QuickSort(int (*cmp)(const R *, const R *))
|
||
{
|
||
int len = Length(), nsr = -1;
|
||
for (int i = 0; i < len - 1; i++)
|
||
{
|
||
for (int j = 0; j < len - 1 - i; j++)
|
||
{
|
||
R *s1 = (*this)[j];
|
||
Node<R> *n1 = m_pCurrent;
|
||
R *s2 = (*this)[j + 1];
|
||
Node<R> *n2 = m_pCurrent;
|
||
|
||
nsr = cmp(s1, s2);
|
||
if (nsr > 0)
|
||
{
|
||
R *tmp = s1;
|
||
n1->data = s2;
|
||
n2->data = tmp;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 可以用关键字查找链表中的某一项, 因此用 void *
|
||
template <class R>
|
||
R * DList<R>::FindNode(const void *target, int (*cmp)(const R *, const void *))
|
||
{
|
||
int len = Length(), nsr = -1;
|
||
for (int i = 0; i < len; i++)
|
||
{
|
||
R *s1 = (*this)[i];
|
||
nsr = cmp(s1, target);
|
||
if (!nsr)
|
||
{
|
||
return s1;
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
template <class R>
|
||
void DList<R>::Swap(int n1,int n2)
|
||
{
|
||
if ((n1 >= 0 && n1 < m_nLen) && ( n2 >= 0 && n2 < m_nLen))
|
||
{
|
||
R* swap1=(*this)[n1];
|
||
Node<R> *node1 = m_pCurrent;
|
||
R* swap2 = (*this)[n2];
|
||
Node<R> *node2 = m_pCurrent;
|
||
R *temp = swap1;
|
||
|
||
node1->data = swap2;
|
||
node2->data = temp;
|
||
}
|
||
else
|
||
{
|
||
assert(NULL);
|
||
}
|
||
}
|
||
|
||
template <class R>
|
||
void DList<R>::Reverse()
|
||
{
|
||
CPtrArray arPtrs;
|
||
int i = 0;
|
||
for (i = 0; i < m_nLen; i++)
|
||
{
|
||
arPtrs.Add((*this)[i]);
|
||
}
|
||
|
||
for (i = 0; i < m_nLen; i++)
|
||
{
|
||
(*this)[i];
|
||
m_pCurrent->data = (R*)arPtrs.GetAt(m_nLen - i - 1);
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
class XCircle;
|
||
class XLine;
|
||
class XPlane;
|
||
class Entity;
|
||
class XGEAPI XPoint
|
||
{
|
||
public:
|
||
XPoint(const ads_point src);
|
||
XPoint(const AcGePoint3d &src);
|
||
XPoint(const AcGePoint2d &src);
|
||
XPoint(const AcGeVector3d &src);
|
||
XPoint(const AcGeVector2d &src);
|
||
XPoint(const XPoint &ptFrom, double dDrt, double dDist);
|
||
XPoint(ads_real dx = 0.0, ads_real dy = 0.0, ads_real dz = 0.0);
|
||
~XPoint();
|
||
|
||
XPoint& operator = (const AcGePoint3d &src);
|
||
XPoint& operator = (const AcGePoint2d &src);
|
||
XPoint& operator = (const AcGeVector3d &src);
|
||
XPoint& operator = (const AcGeVector2d &src);
|
||
XPoint& operator = (const XPoint & pt);
|
||
XPoint& operator = (const ads_point pt);
|
||
|
||
void operator > (ads_point pt) const;
|
||
bool operator > (const XPoint &pt) const;
|
||
bool operator < (const XPoint &pt)const;
|
||
void operator += (const XPoint &pt);
|
||
void operator -= (const XPoint &pt);
|
||
void operator *= (double dScale);
|
||
void operator /= (double dScale);
|
||
bool operator == (const XPoint & pt) const;
|
||
bool operator == (const ads_point pt) const;
|
||
bool operator != (const XPoint &pt) const;
|
||
|
||
operator ads_real* () const;
|
||
operator void* () const;
|
||
|
||
ads_real& operator [] (int i);
|
||
ads_real operator [] (int i) const;
|
||
|
||
int operator ! () const;
|
||
|
||
//3D属性;
|
||
//把当前点往线上投影, rp--结果
|
||
int Project(const AcGeLine3d& gLine,ads_point rp) const;
|
||
int Project(const XLine& aline, ads_point rp) const;
|
||
int Project(const XCircle& aCir, ads_point rp) const;
|
||
XPoint Project(const XPlane& plan) const;
|
||
|
||
double Distance(const XLine* pLine) const;
|
||
double Distance(const XPoint& pt) const;
|
||
double Distance2d(const XPoint& pt) const;
|
||
double Distance(const XPoint& ptSta,const XPoint& ptEnd) const;
|
||
|
||
void TransformBy(ads_matrix mat);
|
||
void TransformBy(const AcGeMatrix3d& mat);
|
||
XPoint TransformAs(ads_matrix mat) const;
|
||
|
||
void GetRotationMatrix(ads_real dRot, ads_matrix mat) const;
|
||
void GetScaleMatrix(ads_real dScale, ads_matrix mat) const;
|
||
void GetScaleMatrix(ads_real sx, ads_real sy, ads_real sz, ads_matrix mat) const;
|
||
void GetMoveMatrix(const XPoint& ptDest, ads_matrix mat) const;
|
||
|
||
void Mirror(const ads_point src, ads_point dest) const;
|
||
void Mirror(const XPoint& ptSrc, XPoint& ptDest) const;
|
||
|
||
void Rotate(ads_real dAng);
|
||
|
||
void Reverse();
|
||
|
||
void Normalize();
|
||
|
||
int Modify(const Entity* pEntity) const;
|
||
int MakeEntity(const Entity* pEntity) const;
|
||
|
||
ads_real Length() const;
|
||
|
||
void Scale(ads_real dScale);
|
||
|
||
operator const AcGePoint3d & ();
|
||
operator AcGePoint3d & () const;
|
||
AcGePoint3d AsAcGePoint3d() const;
|
||
|
||
operator const AcGeVector3d & ();
|
||
operator AcGeVector3d & () const;
|
||
AcGeVector3d AsAcGeVector3d() const;
|
||
|
||
operator const AcGePoint2d & ();
|
||
operator AcGePoint2d & () const;
|
||
AcGePoint2d AsAcGePoint2d() const;
|
||
|
||
operator const AcGeVector2d & ();
|
||
operator AcGeVector2d & () const;
|
||
AcGeVector2d AsAcGeVector2d() const;
|
||
|
||
void AT_xformpt(ads_matrix xform,ads_point pt,ads_point newpt) const;
|
||
|
||
public:
|
||
|
||
ads_real x,y,z;
|
||
};
|
||
|
||
typedef class XPoint Point;
|
||
typedef class XPoint Vector3D;
|
||
typedef class XPoint XVector3D;
|
||
|
||
inline XPoint::XPoint(ads_real dx, ads_real dy, ads_real dz)
|
||
{
|
||
x = dx;
|
||
y = dy;
|
||
z = dz;
|
||
}
|
||
|
||
inline XPoint::XPoint(const ads_point src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = src[2];
|
||
}
|
||
|
||
inline XPoint::XPoint(const XPoint &ptFrom, double dDrt, double dDist)
|
||
{
|
||
ads_polar(ptFrom, dDrt, dDist, *this);
|
||
}
|
||
|
||
inline XPoint::XPoint(const AcGePoint3d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = src[2];
|
||
}
|
||
|
||
inline XPoint::XPoint(const AcGePoint2d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = 0.0;
|
||
}
|
||
|
||
inline XPoint& XPoint::operator = (const AcGePoint3d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = src[2];
|
||
|
||
return *this;
|
||
}
|
||
|
||
inline XPoint& XPoint::operator = (const AcGePoint2d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = 0.0;
|
||
|
||
return *this;
|
||
}
|
||
|
||
inline XPoint::XPoint(const AcGeVector3d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = src[2];
|
||
}
|
||
|
||
inline XPoint::XPoint(const AcGeVector2d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = 0.0;
|
||
}
|
||
|
||
inline XPoint& XPoint::operator = (const AcGeVector3d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = src[2];
|
||
|
||
return *this;
|
||
}
|
||
|
||
inline XPoint& XPoint::operator = (const AcGeVector2d &src)
|
||
{
|
||
x = src[0];
|
||
y = src[1];
|
||
z = 0.0;
|
||
|
||
return *this;
|
||
}
|
||
|
||
inline XPoint& XPoint::operator = (const XPoint & pt)
|
||
{
|
||
x = pt.x;
|
||
y = pt.y;
|
||
z = pt.z;
|
||
|
||
return *this;
|
||
}
|
||
|
||
inline XPoint& XPoint::operator = (const ads_point pt)
|
||
{
|
||
x = pt[0];
|
||
y = pt[1];
|
||
z = pt[2];
|
||
|
||
return *this;
|
||
}
|
||
|
||
inline void XPoint::operator > (ads_point pt) const
|
||
{
|
||
pt[0] = x;
|
||
pt[1] = y;
|
||
pt[2] = z;
|
||
}
|
||
|
||
inline void XPoint::operator += (const XPoint &pt)
|
||
{
|
||
x += pt.x;
|
||
y += pt.y;
|
||
z += pt.z;
|
||
}
|
||
|
||
inline void XPoint::operator -= (const XPoint &pt)
|
||
{
|
||
x -= pt.x;
|
||
y -= pt.y;
|
||
z -= pt.z;
|
||
}
|
||
|
||
inline void XPoint::operator *= (double dScale)
|
||
{
|
||
x *= dScale;
|
||
y *= dScale;
|
||
z *= dScale;
|
||
}
|
||
|
||
inline void XPoint::operator /= (double dScale)
|
||
{
|
||
x /= dScale;
|
||
y /= dScale;
|
||
z /= dScale;
|
||
}
|
||
|
||
inline bool XPoint::operator == (const XPoint & pt) const
|
||
{
|
||
return (fabs(x - pt.x) < 1.e-6 && fabs(y - pt.y) < 1.e-6 && fabs(z - pt.z) < 1.e-6);
|
||
}
|
||
|
||
inline bool XPoint::operator != (const XPoint &pt) const
|
||
{
|
||
return !((*this) == pt);
|
||
}
|
||
|
||
inline bool XPoint::operator == (const ads_point pt) const
|
||
{
|
||
return (ads_distance(&x, pt) < 1.e-6);
|
||
}
|
||
|
||
inline bool XPoint::operator < (const XPoint &pt) const
|
||
{
|
||
return pt > (*this);
|
||
}
|
||
|
||
inline XPoint::operator ads_real*() const
|
||
{
|
||
return (ads_real *)&x;
|
||
}
|
||
|
||
inline XPoint::operator void* () const
|
||
{
|
||
return (void *)&x;
|
||
}
|
||
|
||
inline ads_real& XPoint::operator [] (int i)
|
||
{
|
||
return *(&x + i);
|
||
}
|
||
|
||
inline ads_real XPoint::operator [] (int i) const
|
||
{
|
||
return *(&x + i);
|
||
}
|
||
|
||
inline int XPoint::operator !() const
|
||
{
|
||
return (fabs(x) < 1E-6 && fabs(y) < 1E-6 && fabs(z) < 1E-6) ? 1 : 0;
|
||
}
|
||
|
||
inline double XPoint::Distance(const XPoint& pt) const
|
||
{
|
||
double t1 = pt.x - x;
|
||
double t2 = pt.y - y;
|
||
double t3 = pt.z - z;
|
||
|
||
return sqrt(t1 * t1 + t2 * t2 + t3 * t3);
|
||
}
|
||
|
||
inline double XPoint::Distance2d(const XPoint& pt) const
|
||
{
|
||
double XDis = x - pt.x;
|
||
double YDis = y - pt.y;
|
||
|
||
return sqrt(XDis * XDis + YDis * YDis);
|
||
}
|
||
|
||
inline void XPoint::TransformBy(const AcGeMatrix3d &mat)
|
||
{
|
||
((AcGePoint3d *)this)->transformBy(mat);
|
||
}
|
||
|
||
inline void XPoint::AT_xformpt(ads_matrix xform,ads_point pt,ads_point newpt) const
|
||
{
|
||
int i,j;
|
||
ads_point pt0;
|
||
|
||
newpt[X] = newpt[Y] = newpt[Z] = 0.0;
|
||
pt0[X] = pt[X];pt0[Y] = pt[Y];pt0[Z] = pt[Z];
|
||
|
||
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 XPoint XPoint::TransformAs(ads_matrix mat) const
|
||
{
|
||
XPoint pt;
|
||
AT_xformpt(mat, (double *)&x, pt);
|
||
|
||
return pt;
|
||
}
|
||
|
||
inline void XPoint::TransformBy(ads_matrix mat)
|
||
{
|
||
XPoint pt;
|
||
AT_xformpt(mat, (double *)&x, pt);
|
||
|
||
*this = pt;
|
||
}
|
||
|
||
inline void XPoint::Mirror(const ads_point src, ads_point dest) const
|
||
{
|
||
dest[0] = 2 * x - src[0];
|
||
dest[1] = 2 * y - src[1];
|
||
dest[2] = 2 * z - src[2];
|
||
}
|
||
|
||
inline void XPoint::Mirror(const XPoint & src, XPoint &dest) const
|
||
{
|
||
dest.x = 2 * x - src.x;
|
||
dest.y = 2 * y - src.y;
|
||
dest.z = 2 * z - src.z;
|
||
}
|
||
|
||
inline void XPoint::Rotate(ads_real dang)
|
||
{
|
||
ads_real dewX = x * cos(dang) - y * sin(dang);
|
||
ads_real dewY = x * sin(dang) + y * cos(dang);
|
||
|
||
x = dewX;
|
||
y = dewY;
|
||
}
|
||
|
||
inline void XPoint::Reverse()
|
||
{
|
||
x = -x;
|
||
y = -y;
|
||
z = -z;
|
||
}
|
||
|
||
inline ads_real XPoint::Length() const
|
||
{
|
||
return sqrt(x * x + y * y + z * z);
|
||
}
|
||
|
||
inline void XPoint::Scale(ads_real dScale)
|
||
{
|
||
x *= dScale;
|
||
y *= dScale;
|
||
z *= dScale;
|
||
}
|
||
|
||
inline void XPoint::Normalize()
|
||
{
|
||
double nLen = Length();
|
||
if (nLen > 1.0E-9)
|
||
{
|
||
Scale(1.0 / nLen);
|
||
}
|
||
}
|
||
|
||
inline XPoint::operator const AcGePoint3d & ()
|
||
{
|
||
return *(const AcGePoint3d *)this;
|
||
}
|
||
|
||
inline XPoint::operator AcGePoint3d & () const
|
||
{
|
||
return *(AcGePoint3d *)this;
|
||
}
|
||
|
||
inline AcGePoint3d XPoint::AsAcGePoint3d() const
|
||
{
|
||
return AcGePoint3d(x, y, z);
|
||
}
|
||
|
||
inline XPoint::operator const AcGeVector3d& ()
|
||
{
|
||
return *(const AcGeVector3d *)this;
|
||
}
|
||
|
||
inline XPoint::operator AcGeVector3d& () const
|
||
{
|
||
return *(AcGeVector3d *)this;
|
||
}
|
||
|
||
inline AcGeVector3d XPoint::AsAcGeVector3d() const
|
||
{
|
||
return AcGeVector3d(x, y, z);
|
||
}
|
||
|
||
inline XPoint::operator const AcGePoint2d& ()
|
||
{
|
||
return *(const AcGePoint2d *)this;
|
||
}
|
||
|
||
inline XPoint::operator AcGePoint2d& () const
|
||
{
|
||
return *(AcGePoint2d *)this;
|
||
}
|
||
|
||
inline AcGePoint2d XPoint::AsAcGePoint2d() const
|
||
{
|
||
return AcGePoint2d(x, y);
|
||
}
|
||
|
||
inline XPoint::operator const AcGeVector2d& ()
|
||
{
|
||
return *(const AcGeVector2d *)this;
|
||
}
|
||
|
||
inline XPoint::operator AcGeVector2d& () const
|
||
{
|
||
return *(AcGeVector2d *)this;
|
||
}
|
||
|
||
inline AcGeVector2d XPoint::AsAcGeVector2d() const
|
||
{
|
||
return AcGeVector2d(x, y);
|
||
}
|
||
|
||
inline double XPoint::Distance(const XPoint& ptSta,const XPoint& ptEnd) const
|
||
{
|
||
ads_real* pt0 = *this;
|
||
ads_real* pt1 = ptSta;
|
||
ads_real* pt2 = ptEnd;
|
||
|
||
ads_point pt4;
|
||
|
||
struct plan_para plan;
|
||
XVector3D vt;
|
||
vt[0] = pt2[0] - pt1[0];
|
||
vt[1] = pt2[1] - pt1[1];
|
||
vt[2] = pt2[2] - pt1[2];
|
||
|
||
pt4[0]=pt0[0];
|
||
pt4[1]=pt0[1];
|
||
pt4[2]=pt0[2];
|
||
|
||
plan.A = vt[0];
|
||
plan.B = vt[1];
|
||
plan.C = vt[2];
|
||
plan.D = 0.0 - (vt[0] * pt0[0] + vt[1] * pt0[1] + vt[2] * pt0[2]);
|
||
|
||
double l, m, n, t;
|
||
double mid_var1, mid_var2;
|
||
|
||
l = pt2[0] - pt1[0];
|
||
m = pt2[1] - pt1[1];
|
||
n = pt2[2] - pt1[2];
|
||
|
||
mid_var1 = l * (plan.A) + m * (plan.B) + n * (plan.C);
|
||
if (fabs(mid_var1) < 0.000001)
|
||
{
|
||
return 0.0;
|
||
}
|
||
|
||
mid_var2 = (plan.D) + pt1[0] * (plan.A) + pt1[1] * (plan.B) + pt1[2] * (plan.C);
|
||
t = 0.0 - mid_var2 / mid_var1;
|
||
|
||
pt4[0] = pt1[0] + l * t;
|
||
pt4[1] = pt1[1] + m * t;
|
||
pt4[2] = pt1[2] + n * t;
|
||
|
||
double dist = ads_distance(pt0, pt4);
|
||
return dist;
|
||
}
|
||
|
||
inline XPoint operator + (const XPoint & pt1, const XPoint & pt2)
|
||
{
|
||
return Point(pt1.x + pt2.x, pt1.y + pt2.y, pt1.z + pt2.z);
|
||
}
|
||
|
||
inline XPoint operator - (const XPoint & pt1, const XPoint & pt2)
|
||
{
|
||
return Point(pt1.x - pt2.x, pt1.y - pt2.y, pt1.z - pt2.z);
|
||
}
|
||
|
||
inline XPoint Max(const XPoint &pt1, const XPoint &pt2)
|
||
{
|
||
XPoint upPt;
|
||
upPt.x = max(pt1.x, pt2.x);
|
||
upPt.y = max(pt1.y, pt2.y);
|
||
upPt.z = max(pt1.z, pt2.z);
|
||
return upPt;
|
||
}
|
||
|
||
inline XPoint Min(const XPoint &pt1, const XPoint &pt2)
|
||
{
|
||
XPoint lowPt;
|
||
lowPt.x = min(pt1.x, pt2.x);
|
||
lowPt.y = min(pt1.y, pt2.y);
|
||
lowPt.z = min(pt1.z, pt2.z);
|
||
return lowPt;
|
||
}
|
||
|
||
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 XPoint Ucs2Wcs(XPoint ptSrc, BOOL bVector = FALSE)
|
||
{
|
||
XPoint ptDest;
|
||
Groups g1(1);
|
||
Groups 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);
|
||
Groups 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 g1(vtEcs);
|
||
Groups g0(0);
|
||
ads_trans(ptSrc, (resbuf *)&g1, (resbuf *)&g0, bVector, ptDest);
|
||
|
||
return ptDest;
|
||
}
|
||
|
||
inline XPoint Wcs2Ecs(XPoint ptSrc, XVector3D vtEcs, BOOL bVector = FALSE)
|
||
{
|
||
XPoint ptDest;
|
||
Groups g1(vtEcs);
|
||
Groups g0(0);
|
||
ads_trans(ptSrc, (resbuf *)&g0, (resbuf *)&g1, bVector, ptDest);
|
||
|
||
return ptDest;
|
||
}
|
||
|
||
inline XPoint Ucs2Ecs(XPoint ptSrc, XVector3D vtEcs, BOOL bVector = FALSE)
|
||
{
|
||
XPoint ptDest;
|
||
Groups g1(vtEcs);
|
||
Groups g0(1);
|
||
ads_trans(ptSrc, (resbuf *)&g0, (resbuf *)&g1, bVector, ptDest);
|
||
|
||
return ptDest;
|
||
}
|
||
|
||
inline XPoint Ecs2Ucs(XPoint ptSrc, XVector3D vtEcs, BOOL bVector = FALSE)
|
||
{
|
||
XPoint ptDest;
|
||
Groups v(vtEcs);
|
||
Groups g(1);
|
||
ads_trans(ptSrc, (resbuf *)&v, (resbuf *)&g, 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);
|
||
}
|
||
|
||
class XGEAPI XPointDir2d : public XPoint
|
||
{
|
||
public:
|
||
|
||
XPointDir2d();
|
||
|
||
XPointDir2d(ads_real dDrt);
|
||
|
||
XPointDir2d(const XPointDir2d &src);
|
||
|
||
~XPointDir2d();
|
||
|
||
XPointDir2d & operator = (const XPointDir2d &src);
|
||
|
||
XPoint Polar(ads_real nDist) const;
|
||
|
||
void ShowMe();
|
||
|
||
void TransformBy(ads_matrix mat);
|
||
|
||
XPointDir2d TransformAs(ads_matrix mat) const;
|
||
|
||
public:
|
||
|
||
ads_real nDirection;
|
||
|
||
};
|
||
|
||
class XGEAPI XPointList : public DList<XPoint>
|
||
{
|
||
public:
|
||
|
||
XPointList();
|
||
|
||
XPointList(const XPointList &src);
|
||
|
||
~XPointList();
|
||
|
||
virtual void AppendNode(const XPoint &pt, ads_real dBulge = 0.0);
|
||
|
||
XPointList & operator = (const XPointList& src);
|
||
|
||
void TransUCS(const resbuf *pFrom, const resbuf *pTo);
|
||
|
||
void TransUCS(ads_matrix mat);
|
||
|
||
int GetExtend(ads_point ptMin, ads_point ptMax);
|
||
|
||
int GetExtend(ads_point ptMin, ads_point ptMax) const;
|
||
|
||
XPoint *FindPoint(const XPoint &ptSrc);
|
||
|
||
void Center(ads_point ptCen);
|
||
|
||
void AsPoly2D(XPointList &poly) const;
|
||
|
||
void SetElevation(ads_real dElev);
|
||
|
||
//如果不存在,则末尾添入, 返回点的位置序号
|
||
int NewAppend(const XPoint& ptSrc);
|
||
};
|
||
|
||
class XGEAPI XPolyFacet
|
||
{
|
||
public:
|
||
XPolyFacet(int v1, int v2, int v3, int v4 = 0);
|
||
virtual ~XPolyFacet();
|
||
|
||
int Make(const TCHAR *pszLay = NULL);
|
||
|
||
public:
|
||
int vt1;
|
||
int vt2;
|
||
int vt3;
|
||
int vt4;
|
||
};
|
||
|
||
class XGEAPI XPface: public XPointList
|
||
{
|
||
public:
|
||
~XPface();
|
||
|
||
int Make(const TCHAR *pazLay = NULL);
|
||
|
||
public:
|
||
|
||
DList<XPolyFacet> faces;
|
||
};
|
||
|
||
|
||
// 有序点组成的表
|
||
class XPoly2D;
|
||
class XGEAPI PointList : public XPointList
|
||
{
|
||
public:
|
||
|
||
PointList(const XPoint & startPoint, const XPoint & endPoint, ads_real bulge = 0);
|
||
virtual ~PointList();
|
||
|
||
int Insert(const XPoint & newPt, BOOL bExt = FALSE);
|
||
|
||
int Update(const ads_name ref);
|
||
|
||
void AsPoly2D(XPoly2D &poly) const;
|
||
|
||
public:
|
||
|
||
XPoint center;
|
||
|
||
CurveType curveType;
|
||
};
|
||
|
||
template <class K>
|
||
int xg_setvar(LPCTSTR sym, K val)
|
||
{
|
||
Groups g(val);
|
||
return ads_setvar(sym, (resbuf *)&g);
|
||
}
|
||
|
||
//获取系统变量
|
||
inline int xg_getvar(const TCHAR *var, int *res)
|
||
{
|
||
resbuf v;
|
||
if (ads_getvar(var, &v) != RTNORM || v.restype != RTSHORT )
|
||
{
|
||
return RTERROR;
|
||
}
|
||
*res = v.resval.rint;
|
||
return RTNORM;
|
||
}
|
||
|
||
inline int xg_getvar(const TCHAR *var, XPoint *res)
|
||
{
|
||
resbuf v;
|
||
if (ads_getvar(var, &v) != RTNORM || (v.restype != RT3DPOINT && v.restype != RTPOINT) )
|
||
{
|
||
return RTERROR;
|
||
}
|
||
*res = v.resval.rpoint;
|
||
return RTNORM;
|
||
}
|
||
|
||
inline int xg_getvar(LPCTSTR var, XPoint &res)
|
||
{
|
||
return xg_getvar(var,&res);
|
||
}
|
||
|
||
inline int xg_getvar(const TCHAR *var, double *res)
|
||
{
|
||
resbuf v;
|
||
if (ads_getvar(var, &v) != RTNORM || v.restype != RTREAL )
|
||
{
|
||
return RTERROR;
|
||
}
|
||
*res = v.resval.rreal;
|
||
return RTNORM;
|
||
}
|
||
|
||
inline int xg_getvar(const TCHAR *var, TCHAR *res)
|
||
{
|
||
resbuf v;
|
||
if (ads_getvar(var, &v) != RTNORM || v.restype != RTSTR )
|
||
{
|
||
return RTERROR;
|
||
}
|
||
_tcscpy(res, v.resval.rstring);
|
||
free(v.resval.rstring);
|
||
return RTNORM;
|
||
}
|
||
|
||
inline int xg_getsym(const TCHAR *var, int *res)
|
||
{
|
||
resbuf *v = NULL;
|
||
if (ads_getsym(var, &v) != RTNORM || !v)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
if ( v->restype != RTSHORT )
|
||
{
|
||
ads_relrb(v);
|
||
return RTERROR;
|
||
}
|
||
*res = v->resval.rint;
|
||
ads_relrb(v);
|
||
return RTNORM;
|
||
}
|
||
|
||
inline int xg_getsym(const TCHAR *var, XPoint *res)
|
||
{
|
||
resbuf *v = NULL;
|
||
if (ads_getsym(var, &v) != RTNORM || !v)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
if (v->restype != RT3DPOINT )
|
||
{
|
||
ads_relrb(v);
|
||
return RTERROR;
|
||
}
|
||
*res = v->resval.rpoint;
|
||
ads_relrb(v);
|
||
return RTNORM;
|
||
}
|
||
|
||
inline int xg_getsym(LPCTSTR var, XPoint &res)
|
||
{
|
||
return xg_getsym(var, &res);
|
||
}
|
||
|
||
inline int xg_getsym(const TCHAR *var, double *res)
|
||
{
|
||
resbuf *v = NULL;
|
||
if (ads_getsym(var, &v) != RTNORM || !v)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
if (v->restype != RTREAL )
|
||
{
|
||
ads_relrb(v);
|
||
return RTERROR;
|
||
}
|
||
*res = v->resval.rreal;
|
||
ads_relrb(v);
|
||
return RTNORM;
|
||
}
|
||
|
||
inline int xg_getsym(const TCHAR *var, TCHAR *res)
|
||
{
|
||
resbuf *v;
|
||
if (ads_getsym(var, &v) != RTNORM || !v)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
if (v->restype != RTSTR )
|
||
{
|
||
ads_relrb(v);
|
||
return RTERROR;
|
||
}
|
||
_tcscpy(res, v->resval.rstring);
|
||
ads_relrb(v);
|
||
return RTNORM;
|
||
}
|
||
|
||
class PickSet;
|
||
class XGEAPI Entity : public RBList
|
||
{
|
||
public:
|
||
Entity();
|
||
Entity(const ads_name n);
|
||
Entity(const Entity &ent);
|
||
Entity(LPCTSTR handle);
|
||
~Entity();
|
||
|
||
void operator = (const ads_name n);
|
||
void operator = (const Entity &n);
|
||
int operator !() const;
|
||
|
||
void operator > (ads_name entother) const;
|
||
int operator == (const ads_name ent) const;
|
||
int operator == (const Entity &ent) const;
|
||
|
||
operator LONG_PTR *();
|
||
operator void *();
|
||
|
||
|
||
// 下列函数没有采用ADS命名规则,不建议使用
|
||
int In(const PickSet *pSelectionSet);
|
||
|
||
int Redraw(int mode = 1) const;
|
||
int RedrawAll(int mode = 1) const;
|
||
int Delete() const;
|
||
int Update() const;
|
||
int Erase() const;
|
||
int TypeOfCode(int code);
|
||
|
||
// member functions about groups
|
||
int Make();
|
||
int Modify() const;
|
||
int _GetGroups();
|
||
|
||
// member functions that can get a Entity Name;
|
||
int UserSelect(LPCTSTR prompt,ads_point pt);
|
||
int UserSelect(LPCTSTR prompt = NULL);
|
||
int UserSelect(LPCTSTR prompt,XPoint &pt);
|
||
|
||
int FilterSelect(LPCTSTR prompt, const RBList &mask, ads_point res);
|
||
int FilterSelect(LPCTSTR prompt, const RBList &mask);
|
||
int FilterSelect1(ads_real distPrec, LPCTSTR prmpt, const RBList &mask, ads_point res = NULL);
|
||
|
||
int GetLast();
|
||
int GetNext(const Entity &et);
|
||
int CreateByHandle(LPCTSTR handle);
|
||
|
||
int Handent(LPCTSTR handle);
|
||
int handent(LPCTSTR handle);
|
||
|
||
int GetData(int cd,void *buf);
|
||
int SetData(int cd,...);
|
||
|
||
int Make(int,...);
|
||
int MakeEx(int, ...);
|
||
int GetNext();
|
||
|
||
// member functions to implement Extended Data Access;
|
||
static const TCHAR *ApplicationName;
|
||
static int AssignAppName(const TCHAR *s);
|
||
|
||
// 不建议使用
|
||
int GetGroups(int getEx = 1);
|
||
int GetGroups(const TCHAR *appName);
|
||
void FreeGroups();
|
||
|
||
// 采用ADS命名规则, 建议使用
|
||
int entgetx();
|
||
int entgetx(const TCHAR *appName);
|
||
|
||
int Match(const RBList &exlist);
|
||
int MatchEx(const Groups *tag, const Groups *data);
|
||
int MatchEx(int tag, const TCHAR *data);
|
||
int MatchEx(int tag, int data) ;
|
||
int MatchEx(int tag, ads_real data);
|
||
int MatchEx(int tag, const Groups * data);
|
||
|
||
int MatchBase(const Groups &rb);
|
||
int MatchBase(const RBList &baseList);
|
||
|
||
int Is(const TCHAR *entType);
|
||
|
||
Groups * SearchByTagCode(int tag_code);
|
||
Groups * SearchDataByTag(int tag);
|
||
|
||
// 扩充实体的操作
|
||
int GetInt (int tag_code, int &buf);
|
||
int GetReal(int tag_code, ads_real &buf);
|
||
int GetRString(int tag_cdoe,TCHAR *&buf);
|
||
int GetString (int tag_code,TCHAR *buf);
|
||
int GetPoint(int tag_code, XPoint &buf);
|
||
int GetRBinary(int tag_code, short &nBufLen, const char * &buf);
|
||
|
||
int SetInt (int tag_code,int buf);
|
||
int SetReal(int tag_code,ads_real buf);
|
||
int SetString (int tag_code, const TCHAR *buf, int isHandle = 0);
|
||
int SetPoint(int tag_code, const XPoint &buf);
|
||
int SetBinary(int tag_code, short nBufLen, const char * buf);
|
||
|
||
// support simple type string & int & real
|
||
int SetExData(int tag_code,...);
|
||
int GetExData(int tag_code,void *buf);
|
||
|
||
// 删除指定的扩充实体数据
|
||
int DeleteTag(int tag_code);
|
||
int RemoveXData();
|
||
|
||
int SetStruct(void *buf,int len, int tag_code = EX_STRUCT);
|
||
int GetStruct(void *buf,int len, int tag_code = EX_STRUCT);
|
||
|
||
public:
|
||
ads_name name;
|
||
PGroups groupsEx;
|
||
|
||
private:
|
||
int CreateTag(void *buf,int tag_code,int type);
|
||
void _MakeExGroups();
|
||
};
|
||
|
||
typedef Entity EntityEx;
|
||
inline void Entity::operator = (const ads_name n)
|
||
{
|
||
FreeGroups();
|
||
name[0] = n[0];
|
||
name[1] = n[1];
|
||
}
|
||
|
||
inline void Entity::operator = (const Entity &n)
|
||
{
|
||
FreeGroups();
|
||
*this = n.name;
|
||
}
|
||
|
||
inline void Entity::operator > (ads_name entother) const
|
||
{
|
||
*entother = *name;
|
||
entother[1] = name[1];
|
||
}
|
||
|
||
inline int Entity::operator == (const ads_name ent) const
|
||
{
|
||
return *name == *ent && name[1] == ent[1];
|
||
}
|
||
|
||
inline int Entity::operator == (const Entity &ent) const
|
||
{
|
||
return *this == ent.name;
|
||
}
|
||
|
||
inline int Entity::operator !() const
|
||
{
|
||
return !*name && !name[1];
|
||
}
|
||
|
||
inline Entity::operator LONG_PTR *()
|
||
{
|
||
return name;
|
||
}
|
||
|
||
inline Entity::operator void *()
|
||
{
|
||
return name;
|
||
}
|
||
|
||
inline Entity::Entity() : groupsEx(0)
|
||
{
|
||
*name = name[1] = 0;
|
||
}
|
||
|
||
inline Entity::Entity(const ads_name n): groupsEx(0)
|
||
{
|
||
name[0] = n[0];
|
||
name[1] = n[1];
|
||
}
|
||
|
||
inline Entity::Entity(const Entity &ent): groupsEx(0)
|
||
{
|
||
name[0] = ent.name[0];
|
||
name[1] = ent.name[1];
|
||
}
|
||
|
||
inline Entity::Entity(LPCTSTR handle): groupsEx(0)
|
||
{
|
||
name[0] = name[1] = 0;
|
||
ads_handent((LPCTSTR)handle,name);
|
||
}
|
||
|
||
inline int Entity::Delete() const
|
||
{
|
||
return ads_entdel(name);
|
||
}
|
||
|
||
inline int Entity::UserSelect(LPCTSTR prompt,XPoint &pt)
|
||
{
|
||
return UserSelect(prompt,(double*)&pt);
|
||
}
|
||
|
||
inline int Entity::GetLast()
|
||
{
|
||
FreeGroups();
|
||
return (ads_entlast(name));
|
||
}
|
||
|
||
inline int Entity::Modify() const
|
||
{
|
||
return (ads_entmod((struct resbuf *)groups));
|
||
}
|
||
|
||
inline int Entity::Update() const
|
||
{
|
||
return (ads_entupd(name));
|
||
}
|
||
|
||
inline int Entity::GetNext(const Entity &et)
|
||
{
|
||
FreeGroups();
|
||
return (ads_entnext(et.name,name));
|
||
}
|
||
|
||
inline int Entity::CreateByHandle(LPCTSTR handle)
|
||
{
|
||
return (ads_handent(handle,name));
|
||
}
|
||
|
||
inline int Entity::UserSelect(LPCTSTR prompt,ads_point pt)
|
||
{
|
||
FreeGroups();
|
||
return (ads_entsel(prompt,name,pt));
|
||
}
|
||
|
||
inline int Entity::UserSelect(LPCTSTR prompt)
|
||
{
|
||
FreeGroups();
|
||
ads_point pt;
|
||
return (ads_entsel(prompt,name,pt));
|
||
}
|
||
|
||
inline int Entity::Redraw(int mode) const
|
||
{
|
||
return (ads_redraw(name,mode));
|
||
}
|
||
|
||
inline int Entity::Handent(LPCTSTR handle)
|
||
{
|
||
FreeGroups();
|
||
return ads_handent((LPCTSTR)handle,name);
|
||
}
|
||
|
||
inline int Entity::handent(LPCTSTR handle)
|
||
{
|
||
FreeGroups();
|
||
return ads_handent((LPTSTR)handle,name);
|
||
}
|
||
|
||
inline int Entity::GetData(int cd,void *buf)
|
||
{
|
||
if (!groups)
|
||
{
|
||
_GetGroups();
|
||
}
|
||
return RBList::GetData(cd,buf);
|
||
}
|
||
|
||
inline Groups * Entity::SearchDataByTag(int tag)
|
||
{
|
||
Groups *rbTag = SearchByTagCode(tag);
|
||
if(!rbTag)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return rbTag->next;
|
||
}
|
||
|
||
inline int Entity::GetNext()
|
||
{
|
||
Entity e = *this;
|
||
return GetNext(e);
|
||
}
|
||
|
||
inline void Entity::FreeGroups()
|
||
{
|
||
groupsEx = NULL;
|
||
RBList::FreeGroups();
|
||
}
|
||
|
||
inline int Entity::entgetx()
|
||
{
|
||
return GetGroups();
|
||
}
|
||
|
||
inline int Entity::entgetx(const TCHAR *appName)
|
||
{
|
||
return GetGroups((TCHAR *)appName);
|
||
}
|
||
|
||
inline int Entity::Is(const TCHAR *entType)
|
||
{
|
||
TCHAR eType[40];
|
||
if(GetData(0, eType) == RTNORM && _tcsicmp(eType, entType) == 0)
|
||
{
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
class XGEAPI PickSet
|
||
{
|
||
friend XGEAPI PickSet operator + (const PickSet &, const PickSet &);
|
||
|
||
friend XGEAPI PickSet operator - (const PickSet &, const PickSet &);
|
||
|
||
friend XGEAPI PickSet operator * (const PickSet &, const PickSet &);
|
||
|
||
public:
|
||
|
||
PickSet(int createMode = 0);
|
||
|
||
PickSet(const ads_name n);
|
||
|
||
PickSet(const PickSet & n);
|
||
|
||
virtual ~PickSet();
|
||
|
||
operator LONG_PTR *();
|
||
|
||
int operator !() const;
|
||
|
||
int operator += (const AcDbObjectId &);
|
||
|
||
int operator -= (const AcDbObjectId &);
|
||
|
||
int operator += (const Entity &);
|
||
|
||
int operator -= (const Entity &);
|
||
|
||
int operator += (const PickSet &);
|
||
|
||
int operator -= (const PickSet &);
|
||
|
||
PickSet & operator = (const ads_name n);
|
||
|
||
PickSet & operator = (const PickSet &n);
|
||
|
||
Entity operator [](long index) const;
|
||
|
||
int MakeUnnamedGroup();
|
||
|
||
int Get(LPCTSTR commandString = NULL, void *pt1 = NULL, const ads_point pt2 = NULL);
|
||
|
||
int Get(LPCTSTR commandString, void *pt1, const ads_point pt2, const RBList & entmask);
|
||
|
||
int Get(LPCTSTR commandString, void *pt1, const ads_point pt2, const resbuf * entmask);
|
||
|
||
int Transform(ads_matrix genmat) const;
|
||
|
||
void Get(XPoint ptUcs,const resbuf* entmask = NULL);
|
||
|
||
void GetPreSel(const resbuf* entmask = NULL);
|
||
|
||
void AsIdArray(AcDbObjectIdArray &idArray);
|
||
|
||
void Free();
|
||
|
||
long Length() const;
|
||
|
||
// New Tools
|
||
bool IsInclude(Entity ent)const;
|
||
|
||
void IncludeBegin();
|
||
|
||
void IncludeEnd();
|
||
|
||
void Redraw(int mode = 1) const;
|
||
|
||
void RedrawAll(int mode = 1) const;
|
||
|
||
void Delete() const;
|
||
|
||
int Erase() const;
|
||
|
||
void Bind(const Entity& key);
|
||
|
||
void ExFilter(const RBList &exList);
|
||
|
||
void ExTagFilter(const int *tagList, int sz);
|
||
|
||
//留下满足baseList的实体
|
||
void BaseFilter(RBList &baseList);
|
||
|
||
//排除掉满足baseList的实体
|
||
void BaseExclude(RBList &baseList);
|
||
|
||
int RemoveXData() const;
|
||
|
||
public:
|
||
|
||
ads_name name;
|
||
|
||
Entity mark;
|
||
|
||
unsigned char flag;
|
||
};
|
||
|
||
class XGEAPI XEntity
|
||
{
|
||
public:
|
||
enum TEntityId
|
||
{
|
||
eEntity,
|
||
e3DFace,
|
||
ePlane,
|
||
eHatch,
|
||
eCurve,
|
||
eShape,
|
||
eCircle,
|
||
eArc,
|
||
eLinearEnt,
|
||
eLine,
|
||
eCurveSegment,
|
||
eAFace3D,
|
||
eDbCurveSegEntity,
|
||
eRegionSide,
|
||
eDirectionCurve,
|
||
eCurveSegSeg,
|
||
eCurveSegunique,
|
||
ePoly,
|
||
ePolygonEx,
|
||
ePoly2D,
|
||
ePoly3D,
|
||
eRegion2D
|
||
};
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pImpSrc);
|
||
|
||
virtual void TransformBy(ads_matrix mat);
|
||
virtual int GetExtend(XPoint &ptlow, XPoint &ptup) const;
|
||
//图形长度，周长
|
||
virtual double GetLength() const;
|
||
|
||
virtual int Make(const TCHAR *szlay = NULL) const;
|
||
virtual int MakeEntity(const Entity* pEntity) const;
|
||
virtual int HitTest2d(const XPoint &ptTest) const;
|
||
|
||
virtual int OSnap(int nMode, XPoint &ptPick) const;
|
||
|
||
protected:
|
||
XEntity();
|
||
virtual ~XEntity();
|
||
};
|
||
|
||
class XGEAPI XPlane : public XEntity
|
||
{
|
||
public:
|
||
|
||
XPlane();
|
||
|
||
XPlane(double aa, double bb, double cc, double dd);
|
||
|
||
XPlane(const XPoint &ptOrg, const XVector3D &vtNorm);
|
||
|
||
XPlane(const XPlane &src);
|
||
|
||
virtual ~XPlane();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pImpSrc);
|
||
|
||
virtual BOOL IsValid() const;
|
||
|
||
// 3点确定一平面方程
|
||
virtual BOOL SetFrom3p(const XPoint &pt1, const XPoint &pt2, const XPoint &pt3);
|
||
|
||
// 平面与线求交，考虑了线是否为无限长
|
||
virtual BOOL Intersect(const XLine &ln, XPoint &ptInt) const;
|
||
|
||
// 平面与平面求交，求交线（无限长）
|
||
virtual BOOL Intersect(const XPlane &plan, XLine &ln) const;
|
||
|
||
int InitPlane(const XPoint &pt1, const XPoint &pt2, const XPoint &pt3);
|
||
int InitPlane(const XPoint &pt0, const XVector3D &vt);
|
||
|
||
virtual XVector3D GetNormal() const;
|
||
|
||
virtual double GetAngle(XVector3D vtLight)const;
|
||
|
||
virtual bool IsReflect(XVector3D vtLight)const;
|
||
|
||
virtual bool Reflect(XVector3D vtLight,XVector3D& vtRes)const;
|
||
|
||
virtual double GetParaA()const;
|
||
virtual void SetParaA(const double dVal);
|
||
|
||
virtual double GetParaB()const;
|
||
virtual void SetParaB(const double dVal);
|
||
|
||
virtual double GetParaC()const;
|
||
virtual void SetParaC(const double dVal);
|
||
|
||
virtual double GetParaD()const;
|
||
virtual void SetParaD(const double dVal);
|
||
|
||
XPlane & operator = (const XPlane &src);
|
||
|
||
BOOL operator !() const;
|
||
|
||
public:
|
||
|
||
double m_dParaA, m_dParaB, m_dParaC, m_dParaD;
|
||
};
|
||
|
||
class XGEAPI XCurve : public XEntity
|
||
{
|
||
public:
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
|
||
virtual void TransformBy(ads_matrix mat);
|
||
virtual int GetExtend(XPoint &ptlow, XPoint &ptup) const;
|
||
|
||
virtual ads_real GetLength() const;
|
||
virtual int Make(const TCHAR *szlay = NULL) const;
|
||
virtual int MakeEntity(const Entity* pEntity) const;
|
||
virtual int HitTest2d(const XPoint &ptTest) const;
|
||
virtual int OSnap(int nMode, XPoint &ptPick) const;
|
||
|
||
protected:
|
||
XCurve();
|
||
virtual ~XCurve();
|
||
};
|
||
|
||
class XGEAPI XCell : public XCurve
|
||
{
|
||
public:
|
||
virtual ~XCell(){}
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const
|
||
{
|
||
switch(entType)
|
||
{
|
||
case XEntity::eEntity:
|
||
case XEntity::eCurve:
|
||
case XEntity::eShape:
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
virtual TEntityId Type() const {return XEntity::eShape;}
|
||
|
||
protected:
|
||
virtual ShapeType GetShapeType() const {return SHAPE_UNKNOWN;}
|
||
virtual void Center(ads_point ptCen){}
|
||
virtual ads_real Area(){return 0.0;}
|
||
};
|
||
|
||
class XLine;
|
||
class XGEAPI XPoly : public XCell, public XPointList
|
||
{
|
||
public:
|
||
|
||
XPoly();
|
||
XPoly(resbuf *pts);
|
||
XPoly(const Entity &entPLine);
|
||
XPoly(const XPoly &src);
|
||
|
||
virtual ~XPoly();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pSrc);
|
||
|
||
virtual ShapeType GetShapeType () const;
|
||
virtual void Center(ads_point ptCen);
|
||
|
||
virtual XPoly& operator = (const XPoly &src);
|
||
virtual int operator ! ();
|
||
|
||
virtual int IsPoint();
|
||
virtual int IsLinear();
|
||
virtual int IsRectAngle(ads_point ptcen = NULL, ads_real *pdwidth = NULL, ads_real *pdheight = NULL);
|
||
|
||
virtual int NthLine(int index, XLine &res);
|
||
virtual int CreatePface(const TCHAR *szlay = NULL);
|
||
|
||
virtual resbuf *Fence();
|
||
virtual resbuf *Polygon();
|
||
virtual resbuf *ResbufList(int nIsClosed = 0);
|
||
|
||
virtual ads_real PathArea();
|
||
virtual ads_real Area();
|
||
|
||
virtual int GetExtend(XPoint &ptlow, XPoint &ptup) const;
|
||
};
|
||
|
||
inline int LimitCycle(int n, int nLen)
|
||
{
|
||
if (n < 0)
|
||
{
|
||
n += nLen;
|
||
}
|
||
else if (n >= nLen)
|
||
{
|
||
n -= nLen;
|
||
}
|
||
else
|
||
{
|
||
return n;
|
||
}
|
||
return LimitCycle(n, nLen);
|
||
}
|
||
|
||
template <class R>
|
||
class LoopList : public DList<R>
|
||
{
|
||
public:
|
||
|
||
LoopList();
|
||
~LoopList(){}
|
||
|
||
R * operator [](int n);
|
||
|
||
const R & operator [](int n) const;
|
||
|
||
|
||
const R & GetAt(int n) const;
|
||
R * GetAt(int n);
|
||
|
||
void RemoveNode(int n);
|
||
|
||
};
|
||
|
||
template <class R>
|
||
LoopList<R>::LoopList()
|
||
{
|
||
|
||
}
|
||
|
||
template <class R>
|
||
R * LoopList<R>::operator [](int n)
|
||
{
|
||
int nLen=this->Length();
|
||
n = LimitCycle(n, nLen);
|
||
return DList<R>::operator[](n);
|
||
}
|
||
|
||
template <class R>
|
||
const R & LoopList<R>::operator [](int n) const
|
||
{
|
||
int nLen=this->Length();
|
||
n = LimitCycle(n, nLen);
|
||
const DList<R> &rThis=*this;
|
||
return rThis[n];
|
||
}
|
||
|
||
template <class R>
|
||
R * LoopList<R>::GetAt(int n)
|
||
{
|
||
int nLen = this->Length();
|
||
n = LimitCycle(n, nLen);
|
||
return DList<R>::GetAt(n);
|
||
}
|
||
|
||
template <class R>
|
||
const R & LoopList<R>::GetAt(int n) const
|
||
{
|
||
int nLen = this->Length();
|
||
n = LimitCycle(n, nLen);
|
||
const DList<R> &rThis = *this;
|
||
return rThis.GetAt(n);
|
||
}
|
||
|
||
template <class R>
|
||
void LoopList<R>::RemoveNode(int n)
|
||
{
|
||
(*this)[n];
|
||
this->Remove();
|
||
}
|
||
|
||
inline int Maximum(int n, int r1, ...)
|
||
{
|
||
MAX_MIN(max, int);
|
||
}
|
||
|
||
inline double Maximum(int n, double r1, ...)
|
||
{
|
||
MAX_MIN(max, double);
|
||
}
|
||
|
||
inline int Minimum(int n, int r1, ...)
|
||
{
|
||
MAX_MIN(min, int);
|
||
}
|
||
|
||
inline double Minimum(int n, double r1, ...)
|
||
{
|
||
MAX_MIN(min, double);
|
||
}
|
||
|
||
inline XPoint Maximum(int n, class XPoint r1, ...)
|
||
{
|
||
MAX_MIN(Max, XPoint);
|
||
}
|
||
|
||
inline XPoint Minimum(int n, class XPoint r1, ...)
|
||
{
|
||
MAX_MIN(Min, XPoint);
|
||
}
|
||
|
||
#define FLAG_UNNORMAL 0x10
|
||
#define FLAG_TRIANGLE 0x20 //此时0、3两点相等
|
||
|
||
class XPoly3D;
|
||
class XCurveSegment;
|
||
class X3DFace3Pt;
|
||
class XGEAPI X3DFace : public XEntity
|
||
{
|
||
public:
|
||
|
||
X3DFace(int tag = 0);
|
||
|
||
X3DFace(Entity &entFace, ads_matrix tranMat = NULL);
|
||
|
||
X3DFace(X3DFace3Pt &face1, X3DFace3Pt &face2);
|
||
|
||
X3DFace(const AcDbFace &face);
|
||
|
||
X3DFace(const X3DFace &face);
|
||
|
||
virtual ~X3DFace();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pImpSrc);
|
||
|
||
|
||
//如果是三角形，则移位使得首末点相同
|
||
virtual X3DFace & MakeBetter();
|
||
|
||
virtual int IsLinear() const;
|
||
|
||
virtual int IsPoint() const;
|
||
|
||
virtual int IsRectangular(ads_real *x = NULL, ads_real *y = NULL) const;
|
||
|
||
// nMethod: 0－采用标记来判断，1－采用首没点是否相同来判断，2－采用任意相邻2点相等来判断
|
||
// 执行速度依次递减
|
||
virtual BOOL IsTriangle(int nMethod) const;
|
||
|
||
virtual BOOL IsVisible(int nSide) const;
|
||
|
||
virtual void SetVisible(int nSide, BOOL bTrue);
|
||
|
||
virtual int GetExtend(ads_point lowPt, ads_point upPt) const;
|
||
|
||
virtual int Make(LPCTSTR lay = NULL) const;
|
||
|
||
virtual int Modify(Entity &entFace);
|
||
|
||
virtual void TransformBy(ads_matrix mat);
|
||
|
||
virtual void ExplodeEdge(DList<XCurveSegment> &lstSegs) const;
|
||
|
||
virtual void SetElevation(double nElev);
|
||
|
||
virtual XVector3D GetNormal() const;
|
||
|
||
virtual void Reverse();
|
||
|
||
virtual int GetFlag()const;
|
||
virtual void SetFlag(const int nFlag);
|
||
|
||
virtual XPoint& GetVertex(int nIndex);
|
||
virtual XPoint GetVertex(int nIndex)const;
|
||
virtual void SetVertex(int nIndex, XPoint pt);
|
||
|
||
AcDbFace *AsDbFace() const;
|
||
|
||
//0~3顶点向前/向后移位
|
||
void MoveShift(BOOL bForward);
|
||
|
||
// 对3dface进行切割
|
||
BOOL SectByPlane(const XPlane &plan, DList<X3DFace> &upFaces, DList<X3DFace> &downFaces) const;
|
||
|
||
//vtLight都必须是单位向量！
|
||
virtual XPoly3D GetPoly3D()const;
|
||
|
||
XPlane GetPlane()const;
|
||
|
||
int operator !() const;
|
||
|
||
X3DFace & operator= (const X3DFace &face);
|
||
|
||
X3DFace & operator << (int nBit);
|
||
|
||
X3DFace & operator >> (int nBit);
|
||
|
||
void SubSortVertex();
|
||
BOOL SubSectByX(double xSect, DList<X3DFace> &leftFaces, DList<X3DFace> &rightFaces) const;
|
||
public:
|
||
int m_nFlag;
|
||
XPoint m_ptVertex[4];
|
||
};
|
||
|
||
// 三个顶点的3DFACE, 仅用于特殊用途
|
||
class XGEAPI X3DFace3Pt : public X3DFace
|
||
{
|
||
public:
|
||
|
||
X3DFace3Pt(Entity &entFace);
|
||
~X3DFace3Pt();
|
||
|
||
int GetMergeLine(XLine *pLine);
|
||
|
||
// 返回值： 0~2
|
||
int MergeEdge();
|
||
|
||
// 返回值： 0~2
|
||
int OppHidePoint();
|
||
};
|
||
|
||
|
||
// 用三角形拼多边形
|
||
class XGEAPI XTriangle
|
||
{
|
||
public:
|
||
|
||
XTriangle(const XPoint &pt1, const XPoint &pt2, const XPoint &pt3, int nFlag=0);
|
||
virtual ~XTriangle();
|
||
|
||
void Ecs2Wcs(XVector3D vtEcs);
|
||
void Wcs2Ecs(XVector3D vtEcs);
|
||
|
||
void AsFace(X3DFace &face) const;
|
||
|
||
int IsLinear();
|
||
int IsInvisible();
|
||
|
||
// 1~3－命中1～3点；-1~-3 －命中1~3边；0－外部；4－内部
|
||
int HitTest2d(const XPoint &ptTest) const;
|
||
|
||
enum HitType
|
||
{
|
||
HIT_SIDE1 = -1, //边1
|
||
HIT_SIDE2 = -2, //边2
|
||
HIT_SIDE3 = -3, //边3
|
||
|
||
HIT_OUTSIDE = 0, //外部
|
||
|
||
HIT_VERTEX1 = 1, //顶点1
|
||
HIT_VERTEX2 = 2, //顶点2
|
||
HIT_VERTEX3 = 3, //顶点3
|
||
|
||
HIT_INSIDE = 4 //内部
|
||
};
|
||
|
||
public:
|
||
|
||
int m_nFlag;
|
||
|
||
XPoint vertex1, vertex2, vertex3;
|
||
};
|
||
|
||
class XGEAPI XTrianglePface : public DList< XTriangle >
|
||
{
|
||
|
||
public:
|
||
~XTrianglePface();
|
||
|
||
int MakePolyface(const TCHAR *pszLay = NULL);
|
||
|
||
int MakeSolid(const TCHAR *pszLay = NULL);
|
||
};
|
||
|
||
// 多边形的三角形化
|
||
class XGEAPI XPolygonEx : public XPoly
|
||
{
|
||
public:
|
||
XPolygonEx();
|
||
XPolygonEx(XPoly &src);
|
||
XPolygonEx(Entity &ent);
|
||
XPolygonEx(const XPolygonEx &src);
|
||
virtual ~XPolygonEx();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pSrc);
|
||
|
||
XPoint * operator [](int nIndex);
|
||
const XPoint & operator [](int nIndex) const;
|
||
XPolygonEx & operator = (const XPolygonEx &src);
|
||
|
||
// 求法向量，用来作为坐标变换
|
||
int GetNormal(XVector3D &vtNormal) const;
|
||
|
||
int Make(const TCHAR *szLay);
|
||
|
||
// b2D--TRUE, 已经是二维；否则是三维，需要坐标变换
|
||
int Trianglize(DList<XTriangle> &lstTris, BOOL b2D = FALSE) const;
|
||
int SubTrianglize(DList<XTriangle> &lstTris);
|
||
|
||
int GetInsidePoint(XPoint &ptRet, BOOL b2D = FALSE) const;
|
||
int SubGetInsidePoint(XPoint &ptRet);
|
||
|
||
//是否为凸多边形，2D
|
||
BOOL IsConvex() const;
|
||
BOOL IsVisible(int idx) const;
|
||
|
||
void Reset();
|
||
void Reverse();
|
||
void Ecs2Wcs(XVector3D vtEcs);
|
||
void Wcs2Ecs(XVector3D vtEcs);
|
||
|
||
void SetVisible(int idx, BOOL bVis);
|
||
|
||
void RemoveNode(int nIndex);
|
||
void AppendNode(const XPoint &pt, int nIndex = 1);
|
||
|
||
double GetEdgeLength(int idx) const;
|
||
double GetAngle(int idx) const;
|
||
XPoint GetVertex(int idx) const;
|
||
LoopList<int>& GetVisibleFlag();
|
||
|
||
public:
|
||
// 1--visible; 0-invisible
|
||
LoopList<int> m_lstVisibleFlag;
|
||
};
|
||
|
||
class XHoleModel
|
||
{
|
||
public:
|
||
XHoleModel();
|
||
|
||
virtual ~XHoleModel();
|
||
|
||
virtual void SetOutLine(const XPolygonEx &outline);
|
||
|
||
virtual void GetOutLine(XPolygonEx &outline);
|
||
virtual XPolygonEx &GetOutLine();
|
||
|
||
virtual void AppendHoleList(XPolygonEx *pHole);
|
||
|
||
virtual DList<XPolygonEx> &GetHoleList();
|
||
virtual int GetHoleList(DList<XPolygonEx> &lstPolygonEx);
|
||
|
||
virtual BOOL IsValid() const;
|
||
|
||
virtual BOOL Wcs2Ecs(XVector3D &vtEcs, double &nElev);
|
||
|
||
virtual BOOL Triangulate(BOOL bKeepConstant, DList<XTriangle> &lstTris, BOOL bAs3D = TRUE);
|
||
|
||
public:
|
||
XPolygonEx m_outline;
|
||
DList<XPolygonEx> m_holes;
|
||
};
|
||
|
||
class XArc;
|
||
class XLine;
|
||
class XGEAPI XCircle : public XCell
|
||
{
|
||
public:
|
||
XCircle();
|
||
XCircle(const XCircle &src);
|
||
XCircle(const ads_point, const ads_point);
|
||
XCircle(const ads_point ptcenter,double dradius);
|
||
XCircle(const Entity &entCircle, ads_matrix mat = NULL);
|
||
XCircle(const XPoint &pt1, const XPoint &pt2, const XPoint &pt3);
|
||
virtual ~XCircle();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pSrc);
|
||
|
||
virtual ShapeType GetShapeType() const;
|
||
|
||
virtual int Intersection(const XLine* pLine, ads_point ptrp1 = NULL, ads_point ptrp2 = NULL) const;
|
||
virtual int Intersection(const XArc* pArc, ads_point ptrp1 = NULL, ads_point ptrp2 = NULL) const;
|
||
virtual int Intersection(const XCircle* pCir, ads_point ptrp1 = NULL, ads_point ptrp2 = NULL) const;
|
||
|
||
virtual int GetExtend(ads_point lowPt, ads_point upPt) const;
|
||
virtual int GetSubArc(const XPoint& ptloc, ads_real dchordLen, XArc& xarcres) const;
|
||
|
||
virtual int Make(const TCHAR* szlay = NULL) const;
|
||
virtual int Modify(const Entity* pEntity) const;
|
||
virtual int MakeEntity(const Entity* pEntity) const;
|
||
|
||
virtual void Center(ads_point ptCen);
|
||
//图形长度，周长
|
||
virtual ads_real GetLength() const;
|
||
|
||
virtual ads_real Area() const;
|
||
|
||
virtual int HitTest2d(const XPoint &ptTest) const;
|
||
virtual int OSnap(int nMode, XPoint &ptPick) const;
|
||
|
||
//第一象限点圆心变换,求半径
|
||
virtual void TransUCS(ads_matrix mat);
|
||
|
||
int operator !() const;
|
||
XCircle& operator = (const XCircle &src);
|
||
bool operator == (const XCircle &src) const;
|
||
|
||
XCircle Offset(ads_real dist) const;
|
||
|
||
XPoint GetCenterPt();
|
||
XPoint GetCenterPt() const;
|
||
void SetCenterPt(XPoint pt);
|
||
|
||
double GetRadius() const;
|
||
double GetRadius();
|
||
void SetRadius(double dR);
|
||
bool Set(const XPoint &ptStart, const XPoint &ptOn, const XPoint &ptEnd);
|
||
void Set(const XPoint &diaPt1, const XPoint &diaPt2);
|
||
|
||
int PtOnCircle(const XPoint &pt);
|
||
public:
|
||
XPoint m_ptCenter;
|
||
double m_dRadius;
|
||
};
|
||
|
||
inline XEntity::TEntityId XCircle::Type() const
|
||
{
|
||
return XEntity::eCircle;
|
||
}
|
||
|
||
class XGEAPI XSector
|
||
{
|
||
public:
|
||
XSector();
|
||
XSector(ads_real dStAng, ads_real dEndAng);
|
||
XSector(const XSector & src);
|
||
XSector(const Entity & ent);
|
||
~XSector();
|
||
|
||
XSector& operator = (XSector &src);
|
||
|
||
bool operator == (const XSector &src) const;
|
||
int operator ! () const;
|
||
|
||
// 判断一平面向量是否在扇形区内
|
||
int AngleFlag(ads_real dAng) const;
|
||
|
||
// 找较近的一个角度
|
||
ads_real* NearAngle(ads_real dAng);
|
||
|
||
ads_real Bulge() const;
|
||
ads_real MidAngle() const;
|
||
|
||
void SetAngles(ads_real dStart, ads_real dEnd);
|
||
|
||
void TransUCS(ads_real dIncAngle);
|
||
|
||
void SetStarAngle(ads_real dAngle);
|
||
void SetEndAngle(ads_real dAngle);
|
||
|
||
ads_real GetStarAngle() const;
|
||
ads_real GetEndAngle() const;
|
||
|
||
public:
|
||
double m_dstartAngle;
|
||
double m_dendAngle;
|
||
};
|
||
|
||
class XGEAPI XArc : public XCircle, public XSector
|
||
{
|
||
public :
|
||
XArc(){}
|
||
XArc(const XArc &src): XCircle(src), XSector(src){}
|
||
XArc(const Entity &aCircle): XCircle(aCircle), XSector(aCircle){}
|
||
XArc(const Entity &aArc, ads_matrix mat);
|
||
XArc(const XPoint &spt, const XPoint &ept, ads_real dang);
|
||
XArc(const XPoint &ptStart, const XPoint &pt2, const XPoint &ptEnd);
|
||
XArc(ads_point ptcenter, double dradius, double ptstartAngle, double ptendAngle);
|
||
virtual ~XArc();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pImpSrc);
|
||
|
||
virtual int Make(const TCHAR *szlay = NULL) const;
|
||
virtual int Modify(const Entity* pEnt) const;
|
||
virtual int GetExtend(ads_point lowPt, ads_point upPt) const;
|
||
virtual int MakeEntity(const Entity* pEnt) const;
|
||
virtual int GetSubArc(const XPoint &ptloc, ads_real dchordLen, XArc &arcRes) const;
|
||
//图形长度，周长
|
||
virtual ads_real GetLength() const;
|
||
|
||
XArc& operator = (const XSector &src);
|
||
XArc& operator = (const XArc &src);
|
||
bool operator == (const XArc &src) const;
|
||
int operator ! () const;
|
||
|
||
virtual int HitTest2d(const XPoint &ptTest) const;
|
||
virtual int OSnap(int nMode, XPoint &ptPick) const;
|
||
|
||
bool Set(const XPoint &spt, const XPoint &ept, ads_real dang);
|
||
bool Set(const XPoint &ptStart, const XPoint &ptOn, const XPoint &ptEnd);
|
||
void SetAngleByPoints(const XPoint &ptStart, const XPoint &ptEnd);
|
||
|
||
void GetStartPoint(XPoint &ptStart) const;
|
||
void GetEndPoint(XPoint &ptEnd) const;
|
||
|
||
void MidPoint(XPoint &ptres) const;
|
||
XPoint MidPoint() const;
|
||
|
||
//求弦长
|
||
ads_real ChordLength() const;
|
||
// 扇形面积
|
||
ads_real Area() const;
|
||
//起点到终点的积分面积
|
||
ads_real PathArea() const;
|
||
|
||
XArc Offset(ads_real dist) const;
|
||
|
||
virtual void TransUCS(ads_matrix mat);
|
||
|
||
//$direction
|
||
ads_real IDirection(int pt) const;
|
||
ads_real ODirection(int pt) const;
|
||
|
||
virtual int Intersection(const XLine* pLine, ads_point ptRp1 = NULL, ads_point ptRp2 = NULL) const;
|
||
virtual int Intersection(const XArc* pArc, ads_point ptRp1 = NULL, ads_point ptRp2 = NULL) const;
|
||
virtual int Intersection(const XCircle* pCir, ads_point ptRp1 = NULL, ads_point ptRp2 = NULL) const;
|
||
|
||
ads_real * SelectNear(ads_point pt1, ads_point pt2) const;
|
||
int PtOnArc(const XPoint &pt) const;
|
||
};
|
||
|
||
inline XArc& XArc::operator = (const XSector &src)
|
||
{
|
||
m_dstartAngle = src.m_dstartAngle;
|
||
m_dendAngle = src.m_dendAngle;
|
||
return *this;
|
||
}
|
||
|
||
inline XArc& XArc::operator = (const XArc &src)
|
||
{
|
||
if (this != &src)
|
||
{
|
||
m_dstartAngle = src.m_dstartAngle;
|
||
m_dendAngle = src.m_dendAngle;
|
||
m_ptCenter = src.m_ptCenter;
|
||
m_dRadius = src.m_dRadius;
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
inline int XArc::operator ! () const
|
||
{
|
||
return (XCircle::operator !() || GetLength() < _DIST_SNAP);
|
||
}
|
||
|
||
inline bool XArc::operator == (const XArc &src) const
|
||
{
|
||
return (XCircle::operator == (src) && XSector::operator == (src));
|
||
}
|
||
|
||
inline XArc XArc::Offset(ads_real dist) const
|
||
{
|
||
ads_real r = m_dRadius + dist;
|
||
if (r < _DIST_SNAP)
|
||
{
|
||
r = 0;
|
||
}
|
||
return XArc(m_ptCenter, r, m_dstartAngle, m_dendAngle);
|
||
}
|
||
|
||
inline ads_real XArc::GetLength() const
|
||
{
|
||
return Bulge() * m_dRadius;
|
||
}
|
||
|
||
inline ads_real XArc::ChordLength() const
|
||
{
|
||
return fabs(2.0 * m_dRadius * sin(Bulge() / 2.0));
|
||
}
|
||
|
||
inline void XArc::MidPoint(XPoint &ptres) const
|
||
{
|
||
ads_polar(m_ptCenter, MidAngle(), m_dRadius, ptres);
|
||
}
|
||
|
||
inline XPoint XArc::MidPoint() const
|
||
{
|
||
XPoint ptres;
|
||
ads_polar(m_ptCenter, MidAngle(), m_dRadius, ptres);
|
||
return ptres;
|
||
}
|
||
|
||
class XArc;
|
||
class XCircle;
|
||
class XGEAPI XLinearEnt : public XCurve
|
||
{
|
||
public:
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
|
||
virtual void TransformBy(ads_matrix mat);
|
||
virtual int GetExtend(XPoint &ptlow, XPoint &ptup) const;
|
||
//图形长度，周长
|
||
virtual ads_real GetLength() const;
|
||
virtual int Make(const TCHAR *szlay = NULL) const;
|
||
virtual int MakeEntity(const Entity* pEntity) const;
|
||
|
||
// 0--错误；1－左边；2－右边；3－起始点；4－终止点；5－线内；6－起始侧延长线；7－终止侧延长线
|
||
virtual int HitTest2d(const XPoint &ptTest) const;
|
||
|
||
virtual XPoint MidPoint() const;
|
||
virtual void SetPoints(const XPoint& pt1, const XPoint& pt2);
|
||
virtual int OSnap(int nMode, XPoint &ptPick) const;
|
||
virtual int Intersection(const XArc* pArc, ads_point ptrp1 = NULL, ads_point ptrp2 = NULL) const;
|
||
virtual int Intersection(const XCircle* pCircle, ads_point ptrp1 = NULL, ads_point ptrp2 = NULL) const;
|
||
virtual void CopyFrom(const XEntity* pImpSrc);
|
||
|
||
protected:
|
||
XLinearEnt();
|
||
virtual ~XLinearEnt();
|
||
};
|
||
|
||
class XPoly;
|
||
class XGEAPI XLine : public XLinearEnt
|
||
{
|
||
public:
|
||
XLine(const XLine& src);
|
||
XLine(int nflag = LS_INFINITE);
|
||
XLine(const XPoint& ptThrough, ads_real dDrt);
|
||
XLine(const ads_point p1, const ads_point p2, int _flag = LS_INFINITE);
|
||
XLine(const Entity& entLine, int _flag = LS_INFINITE, ads_matrix tranMat = NULL);
|
||
|
||
virtual ~XLine();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
|
||
virtual void TransUCS(const resbuf *pfrom, const resbuf *pto);
|
||
|
||
virtual void Reverse();
|
||
virtual ads_real PathArea() const;
|
||
|
||
virtual void TransformBy(ads_matrix mat);
|
||
virtual int GetExtend(XPoint &ptlow, XPoint &ptup) const;
|
||
//图形长度，周长
|
||
virtual ads_real GetLength() const;
|
||
|
||
virtual int Make(const TCHAR *szlay = NULL) const;
|
||
virtual int MakeEntity(const Entity* pEntity) const;
|
||
|
||
virtual int HitTest2d(const XPoint &ptTest) const;
|
||
|
||
virtual void SetPoints(const XPoint& pt1, const XPoint& pt2);
|
||
virtual int OSnap(int nMode, XPoint &ptPick) const;
|
||
|
||
virtual int Intersection(const XArc* pArc, ads_point ptrp1 = NULL, ads_point ptrp2 = NULL) const;
|
||
virtual int Intersection(const XCircle* pCircle, ads_point ptrp1 = NULL, ads_point ptrp2 = NULL) const;
|
||
// virtual void CopyFrom(const XEntity* pImpSrc);
|
||
|
||
virtual int Intersection(const XLine* pLine, ads_point ptrp = NULL) const;
|
||
virtual int Intersection(XPoly* pPoly, class PointList& pts) const;
|
||
|
||
int operator ! () const;
|
||
XLine& operator = (const XLine& aLine);
|
||
int operator != (const XLine & aLine) const;
|
||
bool operator == (const XLine & aLine) const;
|
||
|
||
virtual int OnWhichSide(const XPoint &ptsrc) const;
|
||
virtual int Modify(const Entity* pEntity) const;
|
||
virtual int GetSubLine(const XPoint &loc, ads_real dist, XLine &res) const;
|
||
|
||
virtual void SetElevation(ads_real delev);
|
||
|
||
virtual ads_real Direction() const;
|
||
virtual XVector3D Direction3d() const;
|
||
|
||
virtual ads_real* NearPoint(const ads_point pt0);
|
||
virtual ads_real* FarPoint(const ads_point pt0);
|
||
|
||
virtual XLine Offset(ads_real dist) const;
|
||
|
||
virtual void SetLineFlag(int nFlag);
|
||
virtual int GetLineFlag() const;
|
||
|
||
void SetStartPoint(XPoint ptStart);
|
||
void GetStartPoint(XPoint& ptStart);
|
||
XPoint GetStartPoint() const;
|
||
|
||
void SetEndPoint(XPoint ptEnd);
|
||
void GetEndPoint(XPoint& ptEnd);
|
||
XPoint GetEndPoint() const;
|
||
|
||
XPoint& StartPoint();
|
||
XPoint& EndPoint();
|
||
|
||
XPoint& StartPoint() const;
|
||
XPoint& EndPoint() const;
|
||
|
||
void MidPoint(XPoint &ptres) const;
|
||
XPoint MidPoint() const;
|
||
|
||
public:
|
||
XPoint m_startPoint;
|
||
XPoint m_endPoint;
|
||
int m_nFlag;
|
||
};
|
||
|
||
inline int XLine::operator != (const XLine& aLine) const
|
||
{
|
||
return !((*this) == aLine);
|
||
}
|
||
|
||
inline void XLine::SetStartPoint(XPoint ptStart)
|
||
{
|
||
m_startPoint = ptStart;
|
||
}
|
||
|
||
inline void XLine::GetStartPoint(XPoint& ptStart)
|
||
{
|
||
ptStart = m_startPoint;
|
||
}
|
||
|
||
inline XPoint XLine::GetStartPoint() const
|
||
{
|
||
return m_startPoint;
|
||
}
|
||
|
||
inline void XLine::SetEndPoint(XPoint ptEnd)
|
||
{
|
||
m_endPoint = ptEnd;
|
||
}
|
||
|
||
inline void XLine::GetEndPoint(XPoint& ptEnd)
|
||
{
|
||
ptEnd = m_endPoint;
|
||
}
|
||
|
||
inline XPoint XLine::GetEndPoint() const
|
||
{
|
||
return m_endPoint;
|
||
}
|
||
|
||
inline XPoint& XLine::StartPoint()
|
||
{
|
||
return m_startPoint;
|
||
}
|
||
|
||
inline XPoint& XLine::EndPoint()
|
||
{
|
||
return m_endPoint;
|
||
}
|
||
|
||
inline XPoint& XLine::StartPoint() const
|
||
{
|
||
return (XPoint&)m_startPoint;
|
||
}
|
||
|
||
inline XPoint& XLine::EndPoint() const
|
||
{
|
||
return (XPoint&)m_endPoint;
|
||
}
|
||
|
||
inline void XLine::SetLineFlag(int nFlag)
|
||
{
|
||
m_nFlag = nFlag;
|
||
}
|
||
|
||
inline int XLine::GetLineFlag() const
|
||
{
|
||
return m_nFlag;
|
||
}
|
||
|
||
inline void XLine::SetPoints(const XPoint& pt1, const XPoint& pt2)
|
||
{
|
||
m_startPoint = pt1;
|
||
m_endPoint = pt2;
|
||
}
|
||
|
||
inline void XLine::SetElevation(ads_real delev)
|
||
{
|
||
m_startPoint.z = delev;
|
||
m_endPoint.z = delev;
|
||
}
|
||
|
||
inline void XLine::Reverse()
|
||
{
|
||
XPoint pttmp = m_startPoint;
|
||
m_startPoint = m_endPoint;
|
||
m_endPoint = pttmp;
|
||
}
|
||
|
||
inline ads_real* XLine::NearPoint(const ads_point pt0)
|
||
{
|
||
if (ads_distance((ads_real *)pt0, (ads_real *)m_startPoint)
|
||
< ads_distance((ads_real *)pt0, (ads_real *)m_endPoint))
|
||
{
|
||
return &m_startPoint.x;
|
||
}
|
||
|
||
return &m_endPoint.x;
|
||
}
|
||
|
||
inline ads_real* XLine::FarPoint(const ads_point pt0)
|
||
{
|
||
if (ads_distance((ads_real *)pt0, m_startPoint)
|
||
> ads_distance((ads_real *)pt0,m_endPoint))
|
||
{
|
||
return &m_startPoint.x;
|
||
}
|
||
return &m_endPoint.x;
|
||
}
|
||
|
||
inline XPoint XLine::MidPoint() const
|
||
{
|
||
XPoint ptMid;
|
||
ptMid.x = (m_startPoint.x + m_endPoint.x) / 2.0;
|
||
ptMid.y = (m_startPoint.y + m_endPoint.y) / 2.0;
|
||
ptMid.z = (m_startPoint.z + m_endPoint.z) / 2.0;
|
||
|
||
return ptMid;
|
||
}
|
||
|
||
inline void XLine::MidPoint(XPoint& ptres) const
|
||
{
|
||
ptres.x = (m_startPoint.x + m_endPoint.x) / 2.0;
|
||
ptres.y = (m_startPoint.y + m_endPoint.y) / 2.0;
|
||
ptres.z = (m_startPoint.z + m_endPoint.z) / 2.0;
|
||
}
|
||
|
||
inline void XLine::TransUCS(const resbuf *pfrom, const resbuf *pto)
|
||
{
|
||
XPoint spt = m_startPoint, ept = m_endPoint;
|
||
ads_trans(spt, pfrom, pto, 0, m_startPoint);
|
||
ads_trans(ept, pfrom, pto, 0, m_endPoint);
|
||
}
|
||
|
||
inline void XLine::TransformBy(ads_matrix mat)
|
||
{
|
||
m_startPoint.TransformBy(mat);
|
||
m_endPoint.TransformBy(mat);
|
||
}
|
||
|
||
inline bool XLine::IsKindOf(XEntity::TEntityId entType) const
|
||
{
|
||
switch(entType)
|
||
{
|
||
case XEntity::eEntity:
|
||
case XEntity::eCurve:
|
||
case XEntity::eLinearEnt:
|
||
case XEntity::eLine:
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
inline XEntity::TEntityId XLine::Type() const
|
||
{
|
||
return XEntity::eLine;
|
||
}
|
||
|
||
inline int XLine::GetExtend(XPoint &ptlow, XPoint &ptup) const
|
||
{
|
||
XPoint ptStart = m_startPoint;
|
||
XPoint ptEnd = m_endPoint;
|
||
|
||
ptlow = Min(ptStart, ptEnd);
|
||
ptup = Max(ptStart, ptEnd);
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
inline ads_real XLine::GetLength() const
|
||
{
|
||
//return m_startPoint.AsAcGePoint3d().distanceTo(m_endPoint);
|
||
//return ads_distance(m_startPoint,m_endPoint);
|
||
|
||
double t1 = m_startPoint.x - m_endPoint.x;
|
||
double t2 = m_startPoint.y - m_endPoint.y;
|
||
double t3 = m_startPoint.z - m_endPoint.z;
|
||
return sqrt(t1 * t1 + t2 * t2 + t3 * t3);
|
||
}
|
||
|
||
inline ads_real XLine::Direction() const
|
||
{
|
||
return ads_angle(m_startPoint,
|
||
m_endPoint);
|
||
}
|
||
|
||
inline XVector3D XLine::Direction3d() const
|
||
{
|
||
ASSERT(GetLength() > _DIST_SNAP);
|
||
|
||
XVector3D vt = m_endPoint - m_startPoint;
|
||
vt.Normalize();
|
||
|
||
return vt;
|
||
}
|
||
|
||
inline ads_real XLine::PathArea() const
|
||
{
|
||
XPoint ptStart = m_startPoint;
|
||
XPoint ptEnd = m_endPoint;
|
||
|
||
return (ptEnd.x - ptStart.x) * (ptStart.y + ptEnd.y) / 2.0;
|
||
}
|
||
|
||
inline int XLine::operator !() const
|
||
{
|
||
return m_endPoint == m_startPoint;
|
||
}
|
||
|
||
inline bool XLine::operator == (const XLine& aLine) const
|
||
{
|
||
XPoint ptStart = m_startPoint;
|
||
XPoint ptEnd = m_endPoint;
|
||
int nFlag = m_nFlag;
|
||
|
||
XPoint ptStartSrc = aLine.GetStartPoint();
|
||
XPoint ptEndSrc = aLine.GetEndPoint();
|
||
int nFlagSrc = aLine.GetLineFlag();
|
||
|
||
return (nFlag == nFlagSrc
|
||
&& (ptStart == ptStartSrc && ptEnd == ptEndSrc)
|
||
|| (ptStart == ptEndSrc && ptEnd == ptStartSrc));
|
||
}
|
||
|
||
inline XLine& XLine::operator = (const XLine& aLine)
|
||
{
|
||
if (this != &aLine)
|
||
{
|
||
m_startPoint = aLine.m_startPoint;
|
||
m_endPoint = aLine.m_endPoint;
|
||
m_nFlag = aLine.m_nFlag;
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
class XArc;
|
||
class XPoly2D;
|
||
class XGEAPI XCurveSegment : public XLine
|
||
{
|
||
public:
|
||
|
||
XCurveSegment(int flg = LS_FINITE);
|
||
XCurveSegment(const XCurveSegment &src);
|
||
XCurveSegment(const Entity & ent, int flg = LS_FINITE);
|
||
XCurveSegment(const XPoint &spt, const XPoint &ept, ads_real dAng, int flg = LS_FINITE);
|
||
|
||
virtual ~XCurveSegment();
|
||
|
||
XCurveSegment & operator = (const XLine &ln);
|
||
XCurveSegment & operator = (const XArc &arc);
|
||
XCurveSegment & operator = (const XCircle &cir);
|
||
XCurveSegment & operator = (const XCurveSegment &src);
|
||
|
||
bool operator == (const XCurveSegment &src) const;
|
||
|
||
//zjq 2009-08-31 增加line,arc的set函数
|
||
XCurveSegment & SetLine(const XPoint& pt1, const XPoint& pt2);
|
||
XCurveSegment & SetArc(const XPoint &spt, const XPoint &ept, ads_real dang);
|
||
XCurveSegment & SetCircle(const XPoint& ptCen,double dRadius);
|
||
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
virtual void CopyFrom(const XEntity* pSrc);
|
||
|
||
virtual int Make(LPCTSTR lay = NULL) const;
|
||
virtual int MakeEntity(const Entity &e);
|
||
|
||
virtual int HitTest2d(const XPoint &ptTest) const;
|
||
|
||
virtual int OSnap(int nMode, XPoint &ptPick) const;
|
||
|
||
virtual int GetExtend(XPoint &low, XPoint &up) const;
|
||
|
||
virtual int Intersection(const XArc* pArc, ads_point ptRp1 = NULL, ads_point ptRp2 = NULL) const;
|
||
virtual int Intersection(const XCircle* pCircle, ads_point ptRp1 = NULL, ads_point ptRp2 = NULL) const;
|
||
|
||
virtual void TransformBy(ads_matrix mat);
|
||
|
||
virtual void SetPoints(const XPoint &ptStart, const XPoint &ptEnd);
|
||
|
||
//图形长度，周长
|
||
virtual ads_real GetLength() const;
|
||
|
||
virtual XPoint MidPoint() const;
|
||
|
||
// 与曲线方向有关的成员
|
||
virtual XArc GetArc() const;
|
||
|
||
// 0--左（内）；1－右（外）；2－其他 ---> 枚举,下同
|
||
virtual int OnWhichSide(const XPoint &src) const;
|
||
|
||
// 0－左；1－右；2－其他；与上面的区别是，弧段作为有限长，在圆外但在弦的左侧算左
|
||
virtual int OnWhichSide1(const XPoint &src) const;
|
||
|
||
// 从端点开始沿曲线走过给定距离的点向量
|
||
virtual int Polar(ads_real nDist, XPointDir2d &res, int bFromStart = 1) const;
|
||
|
||
virtual void AsPoly2D(XPoly2D &poly) const;
|
||
|
||
virtual ads_real PathArea(XPoint &tmpt) const;
|
||
|
||
// 取得指向内部的方向，线和弧不支持圆。 pt--0:start; 1--end
|
||
virtual ads_real IDirection(int pt) const;
|
||
|
||
// 曲线上的点pt的方向(切向)
|
||
virtual ads_real Direction(const XPoint &pt) const;
|
||
|
||
// 求通过pt点的法向
|
||
virtual ads_real OrthoDirection(const XPoint &pt) const;
|
||
|
||
// 求到端点的沿曲线线位移, 在线内距离为正,否则为负, 和Polar配合使用
|
||
// pt如果不在线上的话则先投影
|
||
virtual ads_real PathDistance(const XPoint &pt, int bFromStart = 1) const;
|
||
|
||
virtual bool IsDirectionCurve();
|
||
|
||
int Is(CurveType t) const;
|
||
|
||
int MakeArrow(Entity &) const;
|
||
|
||
int ProjectToMe(const XPoint &src, XPoint &res) const;
|
||
|
||
int Intersection(const XLine &, ads_point, ads_point) const ;
|
||
int Intersection(const XCurveSegment &, ads_point pt1, ads_point pt2) const;
|
||
|
||
int GetSubSegment(const XPoint &ptloc, ads_real dchordLen, XCurveSegment &ptres) const;
|
||
|
||
//Wcs到展开坐标系
|
||
XPoint Wcs2Ecs(XPoint pt) const;
|
||
//展开坐标系到Wcs
|
||
XPoint Ecs2Wcs(XPoint pt) const;
|
||
|
||
void Wcs2Ecs(const XPoly2D &polyWcs, XPoly2D &polyEcs) const;
|
||
void Ecs2Wcs(const XPoly2D &polyEcs, XPoly2D &polyWcs) const;
|
||
|
||
XCircle GetCircle() const;
|
||
XLine GetLine() const;
|
||
|
||
//点到曲线的距离, 负数为内/左侧
|
||
double GetDist2Me(XPoint ptMid) const;
|
||
|
||
double GetChordLength(double nArcLen) const;
|
||
|
||
CurveType GetCurveType() const;
|
||
|
||
static resbuf *Mask(LPCTSTR lay = NULL);
|
||
|
||
resbuf * AsFence(int nCirDiv = 20) const;
|
||
|
||
AcDbCurve *AsAcDbCurve() const;
|
||
|
||
XCurveSegment Offset(ads_real dDist, int nflg) const;
|
||
XCurveSegment Offset(int lr, ads_real dDist, int nflg) const;
|
||
|
||
double GetBulge() const;
|
||
void SetBulge(const double dBulge);
|
||
public:
|
||
|
||
ads_real m_dBulge;
|
||
};
|
||
|
||
inline int XCurveSegment::Is(CurveType t) const
|
||
{
|
||
double dBulge = fabs(GetBulge());
|
||
return ((dBulge < 1E-6 && t == CURVE_LINE)
|
||
|| (fabs(2.0 * PI - dBulge) < 1E-5 && t == CURVE_CIRCLE)
|
||
|| (dBulge > 1E-6 && dBulge < 2.0 * PI - 1E-6 && t == CURVE_ARC));
|
||
}
|
||
|
||
inline CurveType XCurveSegment::GetCurveType() const
|
||
{
|
||
CurveType t;
|
||
double dBulge = fabs(GetBulge());
|
||
if (dBulge < 1E-6)
|
||
{
|
||
t = CURVE_LINE;
|
||
}
|
||
else if (fabs(2.0 * PI - dBulge) < 1E-5)
|
||
{
|
||
t = CURVE_CIRCLE;
|
||
}
|
||
else
|
||
{
|
||
t = CURVE_ARC;
|
||
}
|
||
|
||
return t;
|
||
}
|
||
|
||
inline XLine XCurveSegment::GetLine() const
|
||
{
|
||
return *this;
|
||
}
|
||
|
||
inline XCurveSegment & XCurveSegment::operator = (const XCurveSegment &src)
|
||
{
|
||
if (this != &src)
|
||
{
|
||
m_nFlag = src.m_nFlag;
|
||
m_startPoint = src.m_startPoint;
|
||
m_endPoint = src.m_endPoint;
|
||
m_dBulge = src.m_dBulge;
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
inline XCurveSegment & XCurveSegment::operator = (const XLine &ln)
|
||
{
|
||
m_nFlag = ln.m_nFlag;
|
||
m_startPoint = ln.m_startPoint;
|
||
m_endPoint = ln.m_endPoint;
|
||
m_dBulge = 0.0;
|
||
return *this;
|
||
}
|
||
|
||
class XGEAPI XDirectionCurve : public XCurveSegment
|
||
{
|
||
public:
|
||
XDirectionCurve(int flg = LS_FINITE);
|
||
XDirectionCurve(const XArc &ar, int bMinus = 0);
|
||
XDirectionCurve(const XDirectionCurve &src);
|
||
XDirectionCurve(const XPoint &spt, const XPoint &ept, ads_real dAng = 0.0, int flg = LS_FINITE);
|
||
|
||
virtual ~XDirectionCurve();
|
||
|
||
virtual int IsMinusArc() const;
|
||
|
||
// 与曲线方向有关的成员
|
||
virtual int OnWhichSide(const XPoint &src) const;
|
||
virtual int OnWhichSide1(const XPoint &src) const;
|
||
|
||
// 从端点开始沿曲线走过给定距离的点向量
|
||
virtual int Polar(ads_real nDist, XPointDir2d &res, BOOL bFromStart = TRUE) const;
|
||
|
||
virtual void Reverse();
|
||
|
||
virtual void TransUCS(ads_matrix mat);
|
||
virtual void TransUCS(const resbuf *, const resbuf *);
|
||
|
||
virtual void AsPoly2D(XPoly2D &poly) const;
|
||
|
||
virtual void SetPoints(const XPoint &ptStart, const XPoint &ptEnd);
|
||
|
||
// 端点处朝曲线段内部的方向
|
||
virtual ads_real IDirection(int pt) const;
|
||
|
||
// 取得指向内部的方向支持Line,Arc，不支持Cir。 pt--0:start; 1--end
|
||
virtual ads_real PathArea(XPoint &tmpt) const;
|
||
|
||
virtual ads_real Direction(const XPoint &pt) const;
|
||
|
||
// 求到端点的沿曲线线位移, 在线内距离为正,否则为负, 和Polar配合使用
|
||
// pt如果不在线上的话则先投影
|
||
virtual ads_real PathDistance(const XPoint &pt, BOOL bFromStart = TRUE) const;
|
||
|
||
// 求通过pt点的法向
|
||
virtual ads_real OrthoDirection(const XPoint &pt) const;
|
||
|
||
// dist left<0 / right>0
|
||
virtual XCurveSegment GetCurve() const;
|
||
virtual XDirectionCurve Offset(ads_real dist, int flg) const;
|
||
|
||
virtual bool IsDirectionCurve();
|
||
|
||
XArc GetArc() const;
|
||
};
|
||
|
||
class XPoly3D;
|
||
class XGEAPI XPoly2D : public XPointList, public XCurve
|
||
{
|
||
public:
|
||
|
||
XPoly2D();
|
||
XPoly2D(const Entity& entPline);
|
||
XPoly2D(int nflg);
|
||
XPoly2D(const XPoly2D & src);
|
||
|
||
virtual ~XPoly2D();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
|
||
virtual double Area() const;
|
||
virtual void Reset();
|
||
virtual bool SetAcDbCurve(AcDbCurve* pCurve);
|
||
|
||
virtual AcDbCurve* AsAcDbCurve()const;
|
||
virtual AcDbRegion *AsRegion() const;
|
||
virtual void CopyFrom(const XEntity* pSrc);
|
||
virtual void AppendNode(const XPoint &pt, ads_real dBulge = 0.0);
|
||
|
||
int operator ! () const;
|
||
XPoly2D& operator = (const XPoly2D &src);
|
||
|
||
void SetFlag(int nFlag);
|
||
int GetFlag() const;
|
||
|
||
void AppendBugle(ads_real dBugle);
|
||
void RemoveBugle(int nIndex);
|
||
|
||
double GetBulge(int nIndex) const;
|
||
void SetBulge(int nIndex, double dBugle);
|
||
|
||
int SetBulges(DList<double>& ardbulges);
|
||
int GetBulges(DList<double>& ardbulges);
|
||
DList<double>& GetBulges();
|
||
|
||
|
||
ads_real Distance3d(int nIndex) const;
|
||
ads_real Distance3d() const;
|
||
ads_real Distance2d(int nIndex) const;
|
||
ads_real Distance2d() const;
|
||
|
||
ads_real PathArea() const;
|
||
|
||
double PathDistance2d(XPoint ptHit) const;
|
||
|
||
int Nth(int nIndex, XLine &xline, XArc &xarc) const;
|
||
int Nth(int nIndex, XCurveSegment & cvCurve) const;
|
||
int Nth(int nIndex, XDirectionCurve &curve) const;
|
||
|
||
//是否自交
|
||
BOOL IsSelfIntersect() const;
|
||
int IsValid(int nIndex) const;
|
||
|
||
int IsClosed() const;
|
||
bool SetClosed();
|
||
|
||
int HasArcSegment() const;
|
||
|
||
int TotalSegments() const;
|
||
|
||
int Polar2d(ads_real dis, XPoint &ptRes, ads_real *dDrt = NULL) const;
|
||
int Polar3d(ads_real dis, XPoint &ptRes, XVector3D & vt) const;
|
||
|
||
int Make(LPCTSTR szLay = NULL) const;
|
||
int MakeSegments(LPCTSTR szLay = NULL) const;
|
||
int MakeSegment(int nIndex, LPCTSTR szLay = NULL) const;
|
||
|
||
//取得封闭PLINE内的一点或外的一点
|
||
XPoint GetPoint(int nIOFlag, ads_real dist);
|
||
XPoint GetInsidePoint();
|
||
|
||
int AppendSegment(const XCurveSegment &cvCurve, int bMinus = 0, int bFinal = 0);
|
||
|
||
int Compress(bool bUnionCurve = true);
|
||
|
||
int Offset(ads_real nDist, XPoly2D &destPoly) const;
|
||
int QuickOffset(ads_real nDist, XPoly2D &destPoly) const;
|
||
|
||
int Reverse();
|
||
|
||
int MapToPolygon1(XPoly &pts, double dDeviation);
|
||
int MapToPolygon(XPoly &pts, int nCirDiv = 30);
|
||
|
||
resbuf *Fence(int nCirDiv = 30);
|
||
resbuf *Polygon(int nCirDiv = 30);
|
||
|
||
int AsOpenPoly1(XPoly &pts, double dDeviation) const;
|
||
int AsOpenPoly(XPoly &pts, int nCirDiv = 30) const;
|
||
|
||
//离散化
|
||
void Disperse1(XPoly2D &polydestPoly, double dDeviation) const;
|
||
void Disperse(XPoly2D &polydestPoly, int nCirDiv = 30) const;
|
||
|
||
int CreatePface(int cirDivSegs, const TCHAR *szLay = NULL);
|
||
|
||
int GetExtend(ads_point lowPt, ads_point upPt) const;
|
||
|
||
int HitTestOnCurve(const XPoint &ptTest, double dTol = _DIST_SNAP) const;
|
||
|
||
void RemoveNode(long nIndex);
|
||
|
||
void InsertNodeAt(int nIndex, const XPoint &pt, double dBulge = 0.0);
|
||
|
||
void SetPointListAt(int nIndex, const XPoint& pt);
|
||
|
||
XPoint* GetPointListAt(int nIndex);
|
||
const XPoint& GetPointListAt(int nIndex) const;
|
||
|
||
void RemovePointListAt(int nIndex);
|
||
void AppendPointListAt(XPoint* pPt);
|
||
|
||
void TransformBy(const AcGeMatrix3d &mat);
|
||
|
||
XPoly3D PlaneToWcs(const AcGeVector3d& normal)const;
|
||
|
||
bool IsRegionInclude(const XPoly2D& poly)const;
|
||
bool IsRegionOverlap(const XPoly2D& poly)const;
|
||
|
||
public:
|
||
|
||
int m_nFlag;
|
||
DList<double> m_ardbulges;
|
||
};
|
||
|
||
extern bool IsMeterfUnitDraw();
|
||
extern Acad::ErrorStatus ReadPoly2D(AcDbDwgFiler *pFiler, XPoly2D &poly);
|
||
extern Acad::ErrorStatus WritePoly2D(AcDbDwgFiler *pFiler, const XPoly2D &poly);
|
||
extern void Split(DList<XPoly2D>&lstLeft,DList<XPoly2D>&lstRight,XPoint ptRidge1,XPoint ptRidge2,const XPoly2D& polyOutline);
|
||
extern AcGeMatrix3d & AsAcGeMatrix3d(ads_matrix mat);
|
||
|
||
class XGEAPI XPoly3D : public XPoly2D
|
||
{
|
||
public:
|
||
|
||
XPoly3D(int nFlag = 0);
|
||
XPoly3D(const Entity & e);
|
||
XPoly3D(const XPoly2D& poly);
|
||
virtual ~XPoly3D();
|
||
|
||
virtual bool IsKindOf(TEntityId entType) const;
|
||
virtual TEntityId Type() const;
|
||
|
||
virtual AcDbCurve* AsAcDbCurve()const;
|
||
|
||
virtual bool SetAcDbCurve(AcDbCurve* pCurve);
|
||
|
||
bool IsPlanear()const;
|
||
|
||
AcGeVector3d GetNormal(bool bCheckConcave)const;
|
||
|
||
XPoly2D WcsToPlane()const;
|
||
|
||
XPoly2D WcsToPlane(const AcGeVector3d& vt)const;
|
||
};
|
||
|
||
class XIntDotPair {
|
||
public:
|
||
short nFrom;
|
||
short nTo;
|
||
public:
|
||
XIntDotPair() {}
|
||
XIntDotPair(short f, short t): nFrom(f), nTo(t) {}
|
||
XIntDotPair(const XIntDotPair &src) {
|
||
nFrom = src.nFrom;
|
||
nTo = src.nTo;
|
||
}
|
||
};
|
||
class XRoofEdge: public XLine {
|
||
public:
|
||
double m_nSlope;
|
||
};
|
||
|
||
class XRoofEdgeCompact {
|
||
public:
|
||
XPoint m_ptVertex;
|
||
double m_nSlope;
|
||
public:
|
||
XRoofEdgeCompact(const XPoint &pt, double nSlant): m_ptVertex(pt), m_nSlope(nSlant)
|
||
{}
|
||
XRoofEdgeCompact() {}
|
||
};
|
||
|
||
// 求标准周期内的整数
|
||
// nPeriod--周期 (>0)
|
||
// nIndex -- 给定的整数
|
||
// 返回: 0~nPeriod-1内的数值
|
||
inline int DePeriod(int nPeriod, int nIndex)
|
||
{
|
||
ASSERT(nPeriod>0);
|
||
while(nIndex>=nPeriod) {
|
||
nIndex -= nPeriod;
|
||
}
|
||
while(nIndex<0) {
|
||
nIndex += nPeriod;
|
||
}
|
||
return nIndex;
|
||
}
|
||
|
||
class XAecRoof {
|
||
public:
|
||
double m_nBottomElevation;
|
||
DList<XRoofEdgeCompact> m_lstEdges;
|
||
BOOL m_bBotVisible;
|
||
|
||
// Not Database Residential data member
|
||
DList<XPointList> m_lstSlopeFaces;
|
||
XPoly2D m_polyBoundry;
|
||
// 临时数据
|
||
DList<XLine> m_lstRidges;
|
||
public:
|
||
XAecRoof(BOOL bBotVis=FALSE) {m_bBotVisible=bBotVis;}
|
||
/*
|
||
XAecRoof(const XAecRoof &src) {
|
||
*this = src;
|
||
}
|
||
XAecRoof(const XPoly2D &poly, double nSlant);*/
|
||
int InitRoof(const XPoly2D &poly, double nSlant);
|
||
|
||
//XAecRoof & operator = (const XAecRoof &src);
|
||
|
||
int InitBottomPolyByEdge();
|
||
int Calculate();
|
||
int CalculateSlopeFace(int n, XPointList &slopeFace);
|
||
int DrawSlopeFaces();
|
||
double GetTotalSurfaceArea() const;
|
||
double GetBottomArea() const {
|
||
ASSERT(!!m_polyBoundry);
|
||
XPoly2D *p = (XPoly2D *)&m_polyBoundry;
|
||
return p->Area();
|
||
}
|
||
double GetSlopeArea(int n) const;
|
||
int GetEdge(int n, XRoofEdge &edge) const;
|
||
int GetPlane(int n, XPlane &slopePlan) const;
|
||
int GetRidge(int n, XLine &ln, int bQuickGet) const;
|
||
int GetTotalEdge() const { return m_lstEdges.Length(); }
|
||
|
||
int GetNext(int nThis, const XPlane &thisPlane,
|
||
int nLast, const XPlane &lastPlane, const XPoint &ptLast,
|
||
int *pNextIndex, XPlane &nextPlane, XPoint &ptNext);
|
||
|
||
int GetEdgeData(XPointList &lstVertices, DList<XIntDotPair> &lstEdgeData) const;
|
||
int GetSurfaceData(int *nVerticeNum, XPoint * &pVerticeList,
|
||
int *nFaceListLen, Adesk::Int32 * &pFaceList,
|
||
Adesk::UInt8 * &pEdgeVisArray) const;
|
||
};
|
||
|
||
typedef struct ShellDraw
|
||
{
|
||
Adesk::Int32 nFaceListLen;
|
||
Adesk::Int32 *pFaceList;
|
||
Adesk::Int32 nVerticeNum;
|
||
AcGePoint3d * pVerticeList;
|
||
AcGiEdgeData* pEdge;
|
||
Adesk::UInt16 nColorIndex;
|
||
AcDbObjectId idLayer;
|
||
}SHELLDRAW;
|
||
|
||
typedef struct MeshDraw
|
||
{
|
||
Adesk::Int32 nRow;
|
||
Adesk::Int32 nCol;
|
||
AcGePoint3d * pVerticeList;
|
||
AcGiEdgeData* pEdge;
|
||
Adesk::UInt16 nColorIndex;
|
||
AcDbObjectId idLayer;
|
||
}MESHDRAW;
|
||
|
||
class XDraw{
|
||
public:
|
||
XDraw(){m_pSubTraits = NULL;}//kColorByLayer
|
||
~XDraw()
|
||
{
|
||
for (int i = 0;i < m_arShells.length();i++)
|
||
{
|
||
ShellDraw& sDr = m_arShells.at(i);
|
||
if (sDr.pVerticeList != NULL)
|
||
delete []sDr.pVerticeList;
|
||
if (sDr.pFaceList != NULL)
|
||
delete []sDr.pFaceList;
|
||
|
||
if (sDr.pEdge != NULL)
|
||
delete sDr.pEdge;
|
||
}
|
||
if (m_pSubTraits != NULL)
|
||
delete m_pSubTraits;
|
||
}
|
||
|
||
Adesk::UInt16 GetColor() const
|
||
{
|
||
if (m_pSubTraits != NULL)
|
||
{
|
||
return m_pSubTraits->colorIndex();
|
||
}
|
||
return kColorByLayer;
|
||
}
|
||
|
||
void SetColor(Adesk::UInt16 nColor)
|
||
{
|
||
if (m_pSubTraits == NULL)
|
||
m_pSubTraits = new AcDbPoint;
|
||
m_pSubTraits->setColorIndex(nColor);
|
||
}
|
||
|
||
void SetColorLayer(Adesk::UInt16 nColor, const AcDbObjectId& id)
|
||
{
|
||
SetColor(nColor);
|
||
|
||
if (m_pSubTraits != NULL)
|
||
{
|
||
m_pSubTraits->setLayer(id);
|
||
}
|
||
}
|
||
|
||
void SetTransparency(bool bTrans)
|
||
{
|
||
|
||
}
|
||
|
||
AcDbObjectId GetColorLayer() const
|
||
{
|
||
if (m_pSubTraits != NULL)
|
||
{
|
||
return m_pSubTraits->layerId();
|
||
}
|
||
return AcDbObjectId::kNull;
|
||
}
|
||
|
||
bool DrawFace(const X3DFace& face)
|
||
{
|
||
m_arFaces.append(face);
|
||
return true;
|
||
}
|
||
|
||
bool DrawMesh(int nRow, int nCol, const AcGePoint3d * ptArray, AcGiEdgeData* pEdge = NULL);
|
||
|
||
void DrawPolyline(AcDbPolyline* pPline)
|
||
{
|
||
if (pPline != NULL)
|
||
{
|
||
m_arEntDraw.append(pPline->clone());
|
||
}
|
||
}
|
||
|
||
void DrawPoly2d(const XPoly2D& poly1)
|
||
{
|
||
AcDbCurve* pPl = poly1.AsAcDbCurve();
|
||
if (pPl != NULL)
|
||
{
|
||
m_arEntDraw.append(pPl);
|
||
}
|
||
}
|
||
|
||
bool DrawShell(const XPoly2D& polyOut1);
|
||
|
||
bool DrawShell(int nVerticeNum,
|
||
const AcGePoint3d *pVerticeList,
|
||
Adesk::Int32 nFaceListLen,
|
||
Adesk::Int32 *pFaceList,
|
||
AcGiEdgeData* pEdge = NULL);
|
||
|
||
bool DrawLine(const XLine& ln)
|
||
{
|
||
m_arLines.append(ln);
|
||
return true;
|
||
}
|
||
|
||
int GetDraw(AcDbVoidPtrArray& entSet);
|
||
|
||
protected:
|
||
|
||
AcArray<X3DFace> m_arFaces;
|
||
AcArray<ShellDraw> m_arShells;
|
||
AcArray<MeshDraw> m_arMeshs;
|
||
AcArray<XLine> m_arLines;
|
||
AcDbVoidPtrArray m_arEntDraw;
|
||
AcDbPoint* m_pSubTraits;
|
||
};
|
||
|
||
class TSlopeRoof {
|
||
public:
|
||
XPoly2D m_polyOutline; //轮廓
|
||
DList<double> m_slope; //倾角
|
||
|
||
//Aec7
|
||
double m_fMaxHeight;
|
||
public:
|
||
TSlopeRoof():m_polyOutline(1){}
|
||
TSlopeRoof(const TSlopeRoof &src);
|
||
TSlopeRoof & operator = (const TSlopeRoof &src);
|
||
|
||
int GetEdgeNum() const {
|
||
return m_slope.Length();
|
||
}
|
||
void Reset();
|
||
void AppendEdge(const XPoint &ptFrom, double nSlope);
|
||
void InitEqualSlope(const XPoly2D &poly, double nSlope);
|
||
double GetAngleToPrev(int idx) const;
|
||
XLine GetSlopeEdge(int idx) const;
|
||
BOOL OffsetIn(double *pDistArray, TSlopeRoof &result) const;
|
||
BOOL IsInOtherEdge(int idx) const;
|
||
void Compress();
|
||
|
||
BOOL GetGeometry(XDraw &dc, BOOL bBotVis) const;
|
||
BOOL GetGeometry1(XDraw &dc, BOOL bBotVis) const;
|
||
BOOL GetGeometry2d(XDraw &dc, BOOL bBotVis) const;
|
||
BOOL GetGeometry2d1(XDraw &dc, BOOL bBotVis) const;
|
||
|
||
double GetSlopeAngle(int idx) const;
|
||
void SetSlopeAngle(int idx, double nAngle);
|
||
void SetElevation(double h) {
|
||
m_polyOutline.SetElevation(h);
|
||
}
|
||
|
||
double GetElevation() const {
|
||
ASSERT(!!m_polyOutline);
|
||
return m_polyOutline[0].z;
|
||
}
|
||
// 底面积
|
||
double GetBottomArea() const {
|
||
return m_polyOutline.Area();
|
||
}
|
||
// 表面积
|
||
double GetSurfArea() const;
|
||
|
||
const XPoly2D & GetOutlinePoly() const {
|
||
return m_polyOutline;
|
||
}
|
||
|
||
void SetPolyPath(const XPoly2D &polyPath);
|
||
void GetPolyPath(XPoly2D &polyPath) const;
|
||
|
||
void SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d&normal);
|
||
void GetPathPoly(XPoly2D &polyPath,AcGeVector3d&normal) const;
|
||
|
||
// 某一边消失时的HMin
|
||
double GetHMin() const;
|
||
|
||
double C(int n1) const {
|
||
int nEdgeNum=GetEdgeNum();
|
||
int n=DePeriod(nEdgeNum, n1);
|
||
const XPoly2D &poly=m_polyOutline;
|
||
return (poly[n].y*poly[DePeriod(nEdgeNum, n+1)].x - poly[n].x*poly[DePeriod(nEdgeNum, n+1)].y);
|
||
}
|
||
double A(int n1) const {
|
||
int nEdgeNum=GetEdgeNum();
|
||
int n=DePeriod(nEdgeNum, n1);
|
||
const XPoly2D &poly=m_polyOutline;
|
||
return (poly[DePeriod(nEdgeNum, n+1)].y - poly[n].y);
|
||
}
|
||
double B(int n1) const {
|
||
int nEdgeNum=GetEdgeNum();
|
||
int n=DePeriod(nEdgeNum, n1);
|
||
const XPoly2D &poly=m_polyOutline;
|
||
return (poly[n].x - poly[DePeriod(nEdgeNum, n+1)].x);
|
||
}
|
||
double E(int n) const { //必须不为0
|
||
double val=(A(n-1)*B(n) - A(n)*B(n-1));
|
||
ASSERT(fabs(val)>1.0E-6);
|
||
return val;
|
||
}
|
||
|
||
double a(int n1) const {
|
||
int nEdgeNum=GetEdgeNum();
|
||
int n=DePeriod(nEdgeNum, n1);
|
||
// return GetSlopeEdge(n).Length();
|
||
return GetSlopeEdge(n).GetLength();
|
||
}
|
||
double Ctan(int n1) const {
|
||
int nEdgeNum=GetEdgeNum();
|
||
int n=DePeriod(nEdgeNum, n1);
|
||
double nAng=GetSlopeAngle(n);
|
||
ASSERT(nAng>0);
|
||
return (fabs(PI/2-nAng)<1.0E-5? 0.0 : 1.0/tan(nAng));
|
||
}
|
||
double r(int n) const {
|
||
return (1.0/E(n)*(B(n-1)*a(n)*Ctan(n) - B(n)*a(n-1)*Ctan(n-1)));
|
||
}
|
||
double s(int n) const {
|
||
return (1.0/E(n)*(B(n-1)*C(n)-B(n)*C(n-1)));
|
||
}
|
||
double u(int n) const {
|
||
return (1.0/E(n)*(A(n)*a(n-1)*Ctan(n-1) - A(n-1)*a(n)*Ctan(n)));
|
||
}
|
||
double v(int n) const {
|
||
return (1.0/E(n)*(A(n)*C(n-1) - A(n-1)*C(n)));
|
||
}
|
||
|
||
double GetHMin(int i, int n) const;
|
||
double GetHMin(int i, int *n) const;
|
||
double GetHMin(int *i, int *n) const;
|
||
BOOL SplitRoof(int iVert, int nEdge, TSlopeRoof &roof1, TSlopeRoof &roof2) const;
|
||
|
||
static bool HitGetPlane(AcGePoint3d& ptHit,AcDbVoidPtrArray& entSet,AcGePlane& plane);
|
||
};
|
||
|
||
class XDormerPar {
|
||
public://老虎窗类型：三角坡、双坡、三坡、梯形坡、平顶窗
|
||
enum XDormerType {SLOPE_TRIANGLE=0,SLOPE_TWO=1,
|
||
SLOPE_THREE=2,SLOPE_TRAPEZIA=3,SLOPE_FLAT=4,};
|
||
public:
|
||
XDormerPar();
|
||
~XDormerPar();
|
||
public:
|
||
XDormerType m_dormerType;//老虎窗类型
|
||
double m_dWallHeight,m_dWallWidth,m_dWallThickness;//墙
|
||
double m_dWindowHeight,m_dWindowWidth;//窗
|
||
double m_dSlopeGrade,m_dSlopeHeight,m_dSlopeThickness;//坡
|
||
double m_dExtendEaves,m_dExtendHill;//伸出长度
|
||
|
||
//图层,外部必须已经建立!!
|
||
AcDbObjectId m_id3DRoof; //顶
|
||
AcDbObjectId m_id3DFloor; //底
|
||
AcDbObjectId m_id3DWall; //墙
|
||
AcDbObjectId m_id3DEaves; //檐
|
||
AcDbObjectId m_id3DGlass; //玻璃
|
||
AcDbObjectId m_id3DWindow; //窗
|
||
|
||
public:
|
||
XDormerPar & operator = (const XDormerPar &src) {
|
||
m_dormerType=src.m_dormerType;
|
||
m_dWallHeight=src.m_dWallHeight;
|
||
m_dWallWidth=src.m_dWallWidth;
|
||
m_dWallThickness=src.m_dWallThickness;
|
||
m_dSlopeGrade=src.m_dSlopeGrade;
|
||
m_dSlopeHeight=src.m_dSlopeHeight;
|
||
m_dSlopeThickness=src.m_dSlopeThickness;
|
||
m_dExtendEaves=src.m_dExtendEaves;
|
||
m_dExtendHill=src.m_dExtendHill;
|
||
m_dWindowHeight=src.m_dWindowHeight;
|
||
m_dWindowWidth=src.m_dWindowWidth;
|
||
m_id3DRoof=src.m_id3DRoof;
|
||
m_id3DFloor=src.m_id3DFloor;
|
||
m_id3DEaves=src.m_id3DEaves;
|
||
m_id3DWall=src.m_id3DWall;
|
||
m_id3DGlass=src.m_id3DGlass;
|
||
m_id3DWindow=src.m_id3DWindow;
|
||
return *this;
|
||
}
|
||
BOOL IsValid() const;
|
||
void SetDormerType(XDormerType dormerType);//老虎窗类型
|
||
void SetWallHeight(double dHeight);//墙
|
||
void SetWallWidth(double dWidth);
|
||
void SetWallThickness(double dThickness);
|
||
void SetWindowHeight(double dHeight);//窗
|
||
void SetWindowWidth(double dWidth);
|
||
void SetSlopeGrade(double dGrade);//坡
|
||
void SetSlopeHeight(double dHeight);
|
||
void SetSlopeThickness(double dThickness);
|
||
void SetExtendEaves(double dEaves);//伸出长度
|
||
void SetExtendHill(double dHill);
|
||
XDormerType GetDormerType() const;
|
||
double GetWallHeight() const;
|
||
double GetWallWidth() const;
|
||
double GetWallThickness() const;
|
||
double GetWindowHeight() const;
|
||
double GetWindowWidth() const;
|
||
double GetSlopeGrade() const;
|
||
double GetSlopeHeight() const;
|
||
double GetSlopeThickness() const;
|
||
double GetExtendEaves() const;
|
||
double GetExtendHill() const;
|
||
|
||
//图层
|
||
void SetRoof(AcDbObjectId idLayer);
|
||
void SetFloor(AcDbObjectId idLayer);
|
||
void SetWall(AcDbObjectId idLayer);
|
||
void SetEaves(AcDbObjectId idLayer);
|
||
void SetGlass(AcDbObjectId idLayer);
|
||
void SetWindow(AcDbObjectId idLayer);
|
||
void SetRoof(const TCHAR *sName);
|
||
void SetFloor(const TCHAR *sName);
|
||
void SetWall(const TCHAR *sName);
|
||
void SetEaves(const TCHAR *sName);
|
||
void SetGlass(const TCHAR *sName);
|
||
void SetWindow(const TCHAR *sName);
|
||
|
||
const TCHAR* GetRoofName() const;
|
||
const TCHAR* GetFloorName() const;
|
||
const TCHAR* GetWallName() const;
|
||
const TCHAR* GetEavesName() const;
|
||
const TCHAR* GetGlassName() const;
|
||
const TCHAR* GetWindowName() const;
|
||
|
||
AcDbObjectId GetRoofId() const;
|
||
AcDbObjectId GetFloorId() const;
|
||
AcDbObjectId GetWallId() const;
|
||
AcDbObjectId GetEavesId() const;
|
||
AcDbObjectId GetGlassId() const;
|
||
AcDbObjectId GetWindowId() const;
|
||
};
|
||
|
||
class XCurveMesh
|
||
{
|
||
public:
|
||
XCurveMesh(){}
|
||
~XCurveMesh(){}
|
||
|
||
protected:
|
||
XPoly2D m_polyBase;
|
||
XPoly2D m_polyShape;
|
||
XVector3D m_vtNormal;
|
||
XPoint m_ptShapeBase;
|
||
Adesk::UInt8 m_nCMFlag;
|
||
|
||
public:
|
||
void SetNormal(const XVector3D &vt);
|
||
void SetShapePoly(const XPoly2D &newShape);
|
||
void SetBasePoly(const XPoly2D &newBase);
|
||
void SetShapeBase(const XPoint &ptBase);
|
||
void ShowShape(BOOL bTrue);
|
||
void SetHas2D(BOOL bTrue);
|
||
void SetHas3D(BOOL bTrue);
|
||
void SetHasDivide2D(BOOL bTrue);
|
||
|
||
Acad::ErrorStatus SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d &normal)
|
||
{
|
||
SetBasePoly(polyPath);
|
||
SetNormal(normal);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus GetPathPoly(XPoly2D &polyPath,AcGeVector3d &normal) const
|
||
{
|
||
polyPath=GetBasePoly();
|
||
normal=m_vtNormal.AsAcGeVector3d();
|
||
return Acad::eOk;
|
||
}
|
||
|
||
XVector3D GetNormal() const;
|
||
const XPoly2D & GetShapePoly() const;
|
||
const XPoly2D & GetBasePoly() const;
|
||
XPoint GetShapeBase() const;
|
||
BOOL IsShapeShow() const;
|
||
BOOL Has2D() const;
|
||
BOOL Has3D() const;
|
||
BOOL HasDivide2D()const;
|
||
BOOL Get2DRegion(XPoly2D &poly2d) const;
|
||
|
||
Acad::ErrorStatus Draw3d(XDraw &dc) const;
|
||
Acad::ErrorStatus Draw2d(XDraw &dc) const;
|
||
};
|
||
|
||
class XDormerWindow
|
||
{
|
||
public:
|
||
XDormerWindow();
|
||
~XDormerWindow();
|
||
|
||
protected:
|
||
XDormerPar m_dormerPar; //老虎窗参数
|
||
XVector3D m_vtDormerDir; //老虎窗方向
|
||
XPoint m_ptDormerBase; //老虎窗基点
|
||
Adesk::Boolean m_bShowWindow; //显示窗户否
|
||
|
||
public:
|
||
//老虎窗基点
|
||
void SetDormerBase(XPoint ptBase);
|
||
XPoint GetDormerBase() const;
|
||
|
||
//老虎窗方向
|
||
void SetDormerDir(XVector3D vtDormerDir);
|
||
XVector3D GetDormerDir() const;
|
||
|
||
//老虎窗参数
|
||
void SetDormerPar(const XDormerPar& dormerPar);
|
||
const XDormerPar & GetDormerPar() const;
|
||
|
||
//显示窗户
|
||
void ShowWindow(BOOL bShow=TRUE);
|
||
BOOL IsShowWindow() const;
|
||
|
||
//老虎窗类型
|
||
const TCHAR* GetDormerType() const;
|
||
|
||
//老虎窗参数的放大和缩小
|
||
Acad::ErrorStatus DormerParTransformBy(const AcGeMatrix3d& xform);
|
||
|
||
public:
|
||
|
||
BOOL IsValid() const;
|
||
|
||
void CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag);
|
||
|
||
const TCHAR *GetDefaultLayer() const;
|
||
|
||
Acad::ErrorStatus getOsnapPoints(
|
||
AcDb::OsnapMode osnapMode,
|
||
INT_PTR gsSelectionMark,
|
||
const AcGePoint3d& ptPick,
|
||
const AcGePoint3d& lastPoint,
|
||
const AcGeMatrix3d& viewXform,
|
||
AcGePoint3dArray& snapPoints,
|
||
AcDbIntArray& geomIds) const;
|
||
|
||
Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
|
||
|
||
Acad::ErrorStatus Draw3d(XDraw &dc) const;
|
||
|
||
Acad::ErrorStatus Draw2d(XDraw &dc) const;
|
||
|
||
Acad::ErrorStatus getGripPoints(AcGePoint3dArray& gripPoints,
|
||
AcDbIntArray& osnapModes,
|
||
AcDbIntArray& geomIds) const;
|
||
Acad::ErrorStatus moveGripPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset);
|
||
|
||
Acad::ErrorStatus dwgInFields (AcDbDwgFiler*);
|
||
Acad::ErrorStatus dwgOutFields(AcDbDwgFiler*) const;
|
||
|
||
private:
|
||
BOOL GetTriangleSlopeVertexs(const double dRoofGrade,
|
||
DList<XPoint>& lstVertex) const;
|
||
BOOL GetTwoSlopeVertexs(const double dRoofGrade,
|
||
DList<XPoint>& lstVertex) const;
|
||
BOOL GetThreeSlopeVertexs(const double dRoofGrade,
|
||
DList<XPoint>& lstVertex) const;
|
||
BOOL GetTrapeziaSlopeVertexs(const double dRoofGrade,
|
||
DList<XPoint>& lstVertex) const;
|
||
BOOL GetFlatWindowVertexs(const double dRoofGrade,
|
||
DList<XPoint>& lstVertex) const;
|
||
|
||
Acad::ErrorStatus DrawTriangleSlope3D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawTwoSlope3D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawThreeSlope3D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawTrapeziaSlope3D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawFlatWindow3D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
|
||
Acad::ErrorStatus DrawTriangleSlope2D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawTwoSlope2D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawThreeSlope2D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawTrapeziaSlope2D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
Acad::ErrorStatus DrawFlatWindow2D(XDraw &dc,
|
||
const AcGeMatrix3d &mat,const double dRoofGrade) const;
|
||
|
||
void DrawWindow(const XPoint& pt1,const XPoint& pt2,
|
||
const XPoint& pt3,XDraw &dc) const;
|
||
void DrawWindow(const XPoint& pt1,const XPoint& pt2,
|
||
const XPoint& pt3,const XPoint& pt4,
|
||
XDraw &dc) const;
|
||
};
|
||
|
||
|
||
//global funcs--------------------------------------------------------------------------------------------------------------------------------------------------
|
||
//裁剪
|
||
XGEAPI int PolyClip(const DList<XCurveSegment> &ss, XPoly2D &poly,DList<XCurveSegment> &ss1, DList<XCurveSegment> &ss2);
|
||
XGEAPI int PolyClip(const DList<XCurveSegment> &ss, const XPoly2D &poly1,DList<XCurveSegment> &ss1, DList<XCurveSegment> &ss2, DList<XCurveSegment> &ssOnEdge);
|
||
XGEAPI int PolyClip(PickSet &ss, XPoly2D &poly, PickSet &ss1, PickSet &ss2);
|
||
XGEAPI int PolyClip(PickSet &ss, XPoly2D &poly, PickSet &ss1, PickSet &ss2, PickSet &ss3);
|
||
|
||
//边界布尔运算
|
||
XGEAPI int Union(const XPoly2D &poly1, const XPoly2D &poly2, DList<XPoly2D> &lstResult);
|
||
XGEAPI int Subtract(const XPoly2D &poly1, const XPoly2D &poly2, DList<XPoly2D> &lstResult);
|
||
XGEAPI int Intersect(const XPoly2D &poly1, const XPoly2D &poly2, DList<XPoly2D> &lstDest);
|
||
|
||
XGEAPI int Union(const DList<XPoly2D> &lstSourcePolies, const DList<XPoly2D> &lstClipPolies, DList<XPoly2D> &lstResultPolies);
|
||
XGEAPI int Subtract(const DList<XPoly2D> &lstSourcePolies, const DList<XPoly2D> &lstClipPolies, DList<XPoly2D> &lstResultPolies);
|
||
XGEAPI int Intersect(const DList<XPoly2D> &lstSourcePolies, const DList<XPoly2D> &lstClipPolies, DList<XPoly2D> &lstResultPolies);
|
||
|
||
//三角化
|
||
//自动搜索最外边界
|
||
XGEAPI BOOL Triangulate(const DList<XPoly2D> &lstHole,DList<XTriangle> &lstRes);
|
||
//自动搜索最外边界
|
||
XGEAPI BOOL Triangulate(const DList<XPolygonEx> &lstHole,DList<XTriangle> &lstRes);
|
||
//给定最外边界
|
||
XGEAPI BOOL Triangulate(const XPoly2D &out,const DList<XPoly2D> &lstHole,DList<XTriangle> &lstRes);
|
||
//给定最外边界
|
||
XGEAPI BOOL Triangulate(const XPolygonEx &out,const DList<XPoly2D> &lstHole,DList<XTriangle> &lstRes);
|
||
//给定最外边界
|
||
XGEAPI BOOL Triangulate(const XPolygonEx &out,const DList<XPolygonEx> &lstHole,DList<XTriangle> &lstRes);
|
||
}
|
||
using namespace XGE;
|
||
#endif |