开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
Polygon.cpp
资源名称：44757463.rar　[点击查看]
上传用户：lj3531212
上传日期：2007-06-18
资源大小：346k
文件大小：20k
源码类别：

绘图程序

开发平台：

Visual C++

Polygon.cpp：源码内容
  1. // Polygon.cpp: implementation of the CPolygon class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "GraphSoft.h"
  7. #include "Polygon.h"
  9. #include "math.h"
  10. #include "GlobalFunction.h"
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  17. ///////////////////////////////////
  18. IMPLEMENT_SERIAL( CPolygon, CShape, 0 )
  19. //////////////////////////////////////////////////////////////////////
  20. // Construction/Destruction
  21. //////////////////////////////////////////////////////////////////////
  22. ///////////////////////////////////////////////////////////////////////
  23. CPolygon::CPolygon():CShape()
  24. {
  25. }
  26. CPolygon::CPolygon(COLORREF color,int penWidth,float angle):CShape(color,penWidth,angle)
  27. {
  28. }
  29. CPolygon::CPolygon(CPolygon * const pPolygon):CShape(pPolygon)
  30. {
  31. int i=pPolygon->m_flArrayxTemp.GetSize();
  32. int j=0;
  33. float fx,fy;
  34. m_flArrayxTemp.RemoveAll();
  35. m_flArrayyTemp.RemoveAll();
  36. while(j++<i){
  37. fx=pPolygon->m_flArrayxTemp.GetAt(j-1);
  38. fy=pPolygon->m_flArrayyTemp.GetAt(j-1);
  39. m_flArrayxTemp.Add(fx);
  40. m_flArrayyTemp.Add(fy);
  41. }
  42. i=pPolygon->m_flArrayx.GetSize();
  43. j=0;
  44. m_flArrayx.RemoveAll();
  45. m_flArrayy.RemoveAll();
  46. while(j++<i){
  47. fx=pPolygon->m_flArrayx.GetAt(j-1);
  48. fy=pPolygon->m_flArrayy.GetAt(j-1);
  49. m_flArrayx.Add(fx);
  50. m_flArrayy.Add(fy);
  51. }
  52. }
  53. CPolygon::~CPolygon()
  54. {
  55. }
  56. ////////////////////////////////////////////////////////////////////////// 
  57. void CPolygon::Serialize( CArchive& ar)
  58. {
  59. CShape::Serialize( ar ) ;
  61. int i=0,j;
  62. if ( ar.IsLoading() ){
  63. float fx,fy;
  64. ar>>i;
  65. j=0;
  66. while(j++ < i){
  67. ar>>fx;
  68. ar>>fy;
  69. m_flArrayx.Add(fx);
  70. m_flArrayy.Add(fy);
  71. //temp
  72. m_flArrayxTemp.Add(fx);
  73. m_flArrayyTemp.Add(fy);
  74. }  
  76. } else {
  77. RefreshData(m_bModified);
  78. i=m_flArrayx.GetSize();
  79. j=0;
  80. ar<<i;
  81. while(j++ < i){
  82. ar<<((float)m_flArrayx.GetAt(j-1));
  83. ar<<((float)m_flArrayy.GetAt(j-1));
  84. }  
  85. }
  86. return ;                  
  87. }
  88. ////////////////////////////////////////////////////////////////////////
  89. void CPolygon::Draw(CDC *pDC,COLORREF color,COLORREF fillColor,int penWidth)
  90. {
  91. if(m_flArrayxTemp.GetSize()!=m_flArrayyTemp.GetSize())
  92. return;
  93. CPen pen,*poldPen;
  94. int i=m_flArrayxTemp.GetSize();
  95.     int j=0;
  96.     pen.CreatePen(PS_SOLID,1, fillColor);
  97. poldPen=pDC->SelectObject(&pen);
  98. if(m_nFillStyle==_shape_solid_fill){
  99. CPoint *ptArray=new CPoint[i];
  100. for(j=0;j<i;j++){
  101. ptArray[j].x=m_flArrayxTemp.GetAt(j);
  102. ptArray[j].y=m_flArrayyTemp.GetAt(j);
  103. }
  104. AreaFill(pDC,i,ptArray,fillColor);
  105. delete[] ptArray;
  106. }
  107.     pen.DeleteObject();
  108. pen.CreatePen(PS_SOLID,penWidth, color);  
  109. pDC->SelectObject(&pen);    
  110. j=0;
  111. pDC->MoveTo(m_flArrayxTemp.GetAt(j),m_flArrayyTemp.GetAt(j));
  112. while(++j<i){
  113. pDC->LineTo(m_flArrayxTemp.GetAt(j),m_flArrayyTemp.GetAt(j));
  114. }
  115. pDC->LineTo(m_flArrayxTemp.GetAt(0),m_flArrayyTemp.GetAt(0));
  117. if(GetDrawPointsFlag()==1){
  118. DrawPoints(pDC,color);
  119. }
  121. pDC->SelectObject(poldPen);  
  122. }
  123. ///////////////////////////////////////////
  124. void CPolygon::DrawPointsCutTo(CDC *pDC,COLORREF color,CFlRect m_rectFrom,CRect m_rectTo)
  125. {
  126. // if(!IsInRect(m_rectFrom)){
  127. // return;
  128. // }
  129. //得到移动扩缩后的关键数据
  130. CArray<float,float> flArrayx;
  131. CArray<float,float> flArrayy;;
  132. //移动
  133. int i=m_flArrayxTemp.GetSize(),j;
  134. float stepx=m_rectTo.left-m_rectFrom.left;
  135. float stepy=m_rectTo.top-m_rectFrom.top;
  136. for(j=0;j<i;j++){
  137. flArrayx.Add(m_flArrayxTemp.GetAt(j)+stepx);
  138. flArrayy.Add(m_flArrayyTemp.GetAt(j)+stepy);
  139. }
  140. //扩缩
  141. float cx,cy,flScale;
  142. cx=m_rectTo.left;
  143. cy=m_rectTo.top;  
  144. if(m_rectFrom.Width()<0.01){
  145. m_rectFrom.right=m_rectFrom.left +1;
  146. }
  147. if(m_rectFrom.Height()<0.01){
  148. m_rectFrom.bottom=m_rectFrom.top +1;
  149. }
  150. flScale=(float)m_rectTo.Width()/m_rectFrom.Width();
  151. //flScale=min((float)m_rectTo.Width()/m_rectFrom.Width(),(float)m_rectTo.Height()/m_rectFrom.Height());
  152. i=flArrayx.GetSize();
  153. for(j=0;j<i;j++){
  154. flArrayx.SetAt(j,(flArrayx.GetAt(j)-cx)*flScale+cx);
  155. flArrayy.SetAt(j,(flArrayy.GetAt(j)-cy)*flScale+cy);
  156. }
  158. CPen pen,*poldPen;
  159.     pen.CreatePen(PS_SOLID,1, color);
  160. poldPen=pDC->SelectObject(&pen);
  161. i=flArrayx.GetSize();
  162. for(j=0;j<i;j++){
  163. pDC->MoveTo(flArrayx.GetAt(j),flArrayy.GetAt(j)-1-GetPenWidth());
  164. pDC->LineTo(flArrayx.GetAt(j),flArrayy.GetAt(j)+2+GetPenWidth());
  165. pDC->MoveTo(flArrayx.GetAt(j)-1-GetPenWidth(),flArrayy.GetAt(j));
  166. pDC->LineTo(flArrayx.GetAt(j)+2+GetPenWidth(),flArrayy.GetAt(j));
  167. }
  168. pDC->SelectObject(poldPen);      
  169. return;
  170. }
  171. void CPolygon::DrawPoints(CDC *pDC,COLORREF color)
  172. {
  173. CPen pen,*poldPen;
  174.     pen.CreatePen(PS_SOLID,1, color);
  175. poldPen=pDC->SelectObject(&pen);
  176. int i=m_flArrayxTemp.GetSize();
  177. for(int j=0;j<i;j++){
  178. pDC->MoveTo(m_flArrayxTemp.GetAt(j),m_flArrayyTemp.GetAt(j)-1-GetPenWidth());
  179. pDC->LineTo(m_flArrayxTemp.GetAt(j),m_flArrayyTemp.GetAt(j)+2+GetPenWidth());
  180. pDC->MoveTo(m_flArrayxTemp.GetAt(j)-1-GetPenWidth(),m_flArrayyTemp.GetAt(j));
  181. pDC->LineTo(m_flArrayxTemp.GetAt(j)+2+GetPenWidth(),m_flArrayyTemp.GetAt(j));
  182. }
  183. pDC->SelectObject(poldPen);      
  184. return;
  185. }
  186. /////////////////
  187. void CPolygon::DrawCutToRect(CDC *pDC,COLORREF color,COLORREF fillColor,int penWidth,CFlRect m_rectFrom,CRect m_rectTo)
  188. {
  189. // if(!IsInRect(m_rectFrom)){
  190. // return;
  191. // }
  192. //得到移动扩缩后的关键数据
  193. CArray<float,float> flArrayx;
  194. CArray<float,float> flArrayy;;
  195. //移动
  196. int i=m_flArrayxTemp.GetSize(),j;
  197. float stepx=m_rectTo.left-m_rectFrom.left;
  198. float stepy=m_rectTo.top-m_rectFrom.top;
  199. for(j=0;j<i;j++){
  200. flArrayx.Add(m_flArrayxTemp.GetAt(j)+stepx);
  201. flArrayy.Add(m_flArrayyTemp.GetAt(j)+stepy);
  202. }
  203. //扩缩
  204. float cx,cy,flScale;
  205. cx=m_rectTo.left;
  206. cy=m_rectTo.top;  
  207. if(m_rectFrom.Width()<0.01){
  208. m_rectFrom.right=m_rectFrom.left +1;
  209. }
  210. if(m_rectFrom.Height()<0.01){
  211. m_rectFrom.bottom=m_rectFrom.top +1;
  212. }
  213. flScale=(float)m_rectTo.Width()/m_rectFrom.Width();
  214. //flScale=min((float)m_rectTo.Width()/m_rectFrom.Width(),(float)m_rectTo.Height()/m_rectFrom.Height());
  215. i=flArrayx.GetSize();
  216. for(j=0;j<i;j++){
  217. flArrayx.SetAt(j,(flArrayx.GetAt(j)-cx)*flScale+cx);
  218. flArrayy.SetAt(j,(flArrayy.GetAt(j)-cy)*flScale+cy);
  219. }
  221. CPen pen,*poldPen;  
  222. i=flArrayx.GetSize();
  223.     j=0;
  224.     pen.CreatePen(PS_SOLID,1, fillColor);
  225. poldPen=pDC->SelectObject(&pen);
  226. if(m_nFillStyle==_shape_solid_fill){
  227. CPoint *ptArray=new CPoint[i];
  228. for(j=0;j<i;j++){
  229. ptArray[j].x=flArrayx.GetAt(j);
  230. ptArray[j].y=flArrayy.GetAt(j);
  231. }
  232. AreaFill(pDC,i,ptArray,fillColor);
  233. delete[] ptArray;
  234. }
  235.     pen.DeleteObject();
  236. pen.CreatePen(PS_SOLID,penWidth, color);  
  237. pDC->SelectObject(&pen);    
  238. j=0;
  239. pDC->MoveTo(flArrayx.GetAt(j),flArrayy.GetAt(j));
  240. while(++j<i){
  241. pDC->LineTo(flArrayx.GetAt(j),flArrayy.GetAt(j));
  242. }
  243. pDC->LineTo(flArrayx.GetAt(0),flArrayy.GetAt(0));
  247. if(GetDrawPointsFlag()==1){
  248. DrawPointsCutTo(pDC,color,m_rectFrom,m_rectTo);
  249. }
  251. pDC->SelectObject(poldPen);
  252. // flArrayx.RemoveAll();
  253. // flArrayy.RemoveAll();
  254. }
  255. ////////////////////////////////////////////////////////////////////////////
  256. ////////////////////////////////////////////////////////////////////////////
  257. void CPolygon::RefreshData(bool bRefresh)
  258. {
  259. if(bRefresh){
  261. int i=m_flArrayxTemp.GetSize();
  262. int j=0;
  263. float fx,fy;
  264. m_flArrayx.RemoveAll();
  265. m_flArrayy.RemoveAll();
  266. while(j++<i){
  267. fx=m_flArrayxTemp.GetAt(j-1);
  268. fy=m_flArrayyTemp.GetAt(j-1);
  269. m_flArrayx.Add(fx);
  270. m_flArrayy.Add(fy);
  271. }
  273. m_bModified=FALSE;
  274. m_ptMagnifyCenterTemp=CPoint(0,0);
  275. m_flScaleTemp=1;
  276. m_ptRotateCenterTemp=CPoint(0,0);
  277. m_flAngleTemp=0;
  278. }
  279. }
  280. void CPolygon::CreatGraph(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY,int nPenWidth,COLORREF color,COLORREF fillColor,SHAPE_FILLSTYLE nStyle)
  281. {
  282. //if(ptArray.GetSize()<2){
  283. // return;
  284. //}
  285. CShape::CreatGraph(flArrayX,flArrayY,nPenWidth,color,fillColor,nStyle);
  287. int i=flArrayX.GetSize();
  288. int j=0;
  289. float flx,fly;
  290. m_flArrayx.RemoveAll();
  291. m_flArrayy.RemoveAll();
  292. m_flArrayxTemp.RemoveAll();
  293. m_flArrayyTemp.RemoveAll();
  295. while(j++<i){
  296. flx=flArrayX.GetAt(j-1);
  297. fly=flArrayY.GetAt(j-1);
  298. m_flArrayx.Add(flx);
  299. m_flArrayy.Add(fly);
  300. //temp
  301. m_flArrayxTemp.Add(flx);
  302. m_flArrayyTemp.Add(fly);
  303. }
  304. }
  305. void CPolygon::CreatGraph(CArray<CPoint,CPoint>& ptArray,int nPenWidth,COLORREF color,COLORREF fillColor,SHAPE_FILLSTYLE nStyle)
  306. {
  307. //if(ptArray.GetSize()<2){
  308. // return;
  309. //}
  310. CShape::CreatGraph(ptArray,nPenWidth,color,fillColor,nStyle);
  312. int i=ptArray.GetSize();
  313. int j=0;
  314. CPoint pt;
  315. m_flArrayx.RemoveAll();
  316. m_flArrayy.RemoveAll();
  317. m_flArrayxTemp.RemoveAll();
  318. m_flArrayyTemp.RemoveAll();
  320. while(j++<i){
  321. pt=ptArray.GetAt(j-1);
  322. m_flArrayx.Add(pt.x);
  323. m_flArrayy.Add(pt.y);
  324. //temp
  325. m_flArrayxTemp.Add(pt.x);
  326. m_flArrayyTemp.Add(pt.y);
  327. //TRACE("%d---(%d,%d)n",j,pt.x,pt.y);
  328. }
  329. }
  330. void CPolygon::SetPtData(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY)
  331. {
  332. m_flArrayx.Copy(flArrayX);
  333. m_flArrayxTemp.Copy(flArrayX);
  334. m_flArrayy.Copy(flArrayY);
  335. m_flArrayyTemp.Copy(flArrayY);
  336. }
  337. void CPolygon::GetPtData(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY)
  338. {
  339. flArrayX.Copy(m_flArrayxTemp);
  340. flArrayY.Copy(m_flArrayyTemp);
  341. }
  342. CShape* CPolygon::GetCopy()
  343. {
  344. CShape* pGraph=new CPolygon(this);
  345. return pGraph;  
  346. }
  347. ////////////////////////////////////////////////////////////////////////////
  348. ////////////////////////////////////////////////////////////////////////////
  349. void CPolygon::Move(CDC *pDC,float stepx,float stepy)
  350. {
  351. RefreshData(m_bModified);
  352. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  353. int i=m_flArrayxTemp.GetSize();
  354. int j=0;
  355. float fx,fy;
  356. while(j++<i){
  357. fx=m_flArrayxTemp.GetAt(j-1);
  358. fy=m_flArrayyTemp.GetAt(j-1);
  359. m_flArrayx.SetAt(j-1,fx+stepx);
  360. m_flArrayy.SetAt(j-1,fy+stepy);
  362. m_flArrayxTemp.SetAt(j-1,fx+stepx);
  363. m_flArrayyTemp.SetAt(j-1,fy+stepy);
  364. }
  365. }
  366. void CPolygon::PartMove(CDC *pDC,float PrevX,float PrevY,float CurX,float CurY)
  367. {
  368. RefreshData(m_bModified);
  369.     if(m_nSelectPtNum>-1){
  370. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  371. m_flArrayxTemp.SetAt(m_nSelectPtNum,CurX);
  372. m_flArrayyTemp.SetAt(m_nSelectPtNum,CurY);
  373. m_flArrayx.SetAt(m_nSelectPtNum,CurX);
  374. m_flArrayy.SetAt(m_nSelectPtNum,CurY);
  375. // CShape::Draw(pDC);
  376.     }else if(m_nSelectLineNum>-1){
  377. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  378. float flCut1x,flCut1y,flCut2x,flCut2y;
  379. float flX1[4],flY1[4],flX2[4],flY2[4];
  380. int nptNum=m_flArrayyTemp.GetSize();
  382. flX1[0]=m_flArrayx.GetAt((nptNum+m_nSelectLineNum-1)%nptNum);
  383. flY1[0]=m_flArrayy.GetAt((nptNum+m_nSelectLineNum-1)%nptNum);
  384. flX1[1]=CurX;
  385. flY1[1]=CurY;    
  386. flX1[2] = m_flArrayx.GetAt((nptNum+m_nSelectLineNum)%nptNum);
  387. flY1[2] = m_flArrayy.GetAt((nptNum+m_nSelectLineNum)%nptNum);
  388. flX1[3] = m_flArrayx.GetAt((nptNum+m_nSelectLineNum+1)%nptNum);
  389. flY1[3] = m_flArrayy.GetAt((nptNum+m_nSelectLineNum+1)%nptNum);
  390.     flX2[0]=m_flArrayx.GetAt((nptNum+m_nSelectLineNum+2)%nptNum);
  391. flY2[0]=m_flArrayy.GetAt((nptNum+m_nSelectLineNum+2)%nptNum);
  392. flX2[1]=CurX;
  393. flY2[1]=CurY;    
  394. flX2[2] = flX1[2];
  395. flY2[2] = flY1[2];
  396. flX2[3] = flX1[3];
  397. flY2[3] = flY1[3];
  399. if(GetCutPtFrom2Line(flX1,flY1,&flCut1x,&flCut1y) && GetCutPtFrom2Line(flX2,flY2,&flCut2x,&flCut2y)){
  401. if(fabs(flCut1x-flX1[0])>0.01){
  402. m_flArrayxTemp.SetAt((nptNum+m_nSelectLineNum)%nptNum,(flX1[2]-flX1[0])*((float)CurX-flCut1x)/(flCut1x-flX1[0])+flX1[2]);
  403. } 
  404. if(fabs(flCut1y-flY1[0])>0.01){
  405. m_flArrayyTemp.SetAt((nptNum+m_nSelectLineNum)%nptNum,(flY1[2]-flY1[0])*((float)CurY-flCut1y)/(flCut1y-flY1[0])+flY1[2]);
  406. }
  407. if(fabs(flCut2x-flX2[0])>0.01){
  408. m_flArrayxTemp.SetAt((nptNum+m_nSelectLineNum+1)%nptNum,(flX2[3]-flX2[0])*((float)CurX-flCut2x)/(flCut2x-flX2[0])+flX2[3]);
  409. } 
  410. if(fabs(flCut2y-flY2[0])>0.01){
  411. m_flArrayyTemp.SetAt((nptNum+m_nSelectLineNum+1)%nptNum,(flY2[3]-flY2[0])*((float)CurY-flCut2y)/(flCut2y-flY2[0])+flY2[3]);
  412. }
  413. }
  414. // CShape::Draw(pDC);
  415. }
  417. }
  418. void CPolygon::Rotate(CDC *pDC,float CX,float CY,float flAngle)
  419. {
  420. if(m_flScaleTemp!=1){
  421. RefreshData(TRUE);
  422. }
  424. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  426. m_ptRotateCenterTemp=CPoint(CX,CY);
  427. m_flAngleTemp=flAngle;
  428. m_bModified=TRUE;
  430. int i=m_flArrayx.GetSize();
  431. int j=0;
  432. float fx,fy,fxTemp,fyTemp;
  433. while(j++<i){
  434. fx=m_flArrayx.GetAt(j-1);
  435. fy=m_flArrayy.GetAt(j-1);
  437. fxTemp=((fx-CX)*cos(flAngle)-(fy-CY)*sin(flAngle))+CX;
  438. fyTemp=((fy-CY)*cos(flAngle)+(fx-CX)*sin(flAngle))+CY;
  440. m_flArrayxTemp.SetAt(j-1,fxTemp);
  441. m_flArrayyTemp.SetAt(j-1,fyTemp);
  442. }
  443. }
  444. void CPolygon::Magnify(CDC *pDC,float CX,float CY,float flScale)
  445. {
  446. if(m_flAngleTemp!=0){
  447. RefreshData(TRUE);
  448. }
  449. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));  
  450. m_ptMagnifyCenterTemp=CPoint(CX,CY);
  451. m_flScaleTemp=flScale;
  452. m_bModified=TRUE;
  454. int i=m_flArrayx.GetSize();
  455. int j=0;
  456. float fx,fy;
  457. while(j++<i){
  458. fx=m_flArrayx.GetAt(j-1);
  459. fy=m_flArrayy.GetAt(j-1);
  461. fx=(fx-CX)*flScale+CX;
  462. fy=(fy-CY)*flScale+CY;
  464. m_flArrayxTemp.SetAt(j-1,fx);
  465. m_flArrayyTemp.SetAt(j-1,fy);
  466. }
  467. }
  468. void CPolygon::LeftToRight(CDC* pDC,CRect rect)
  469. {
  470. RefreshData(m_bModified);
  471. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  473. int i=m_flArrayx.GetSize();
  474. for(int j=0;j<i;j++){
  475. m_flArrayx.SetAt(j,rect.left/1000.0+rect.right/1000.0-m_flArrayx.GetAt(j));
  476. m_flArrayxTemp.SetAt(j,rect.left/1000.0+rect.right/1000.0-m_flArrayxTemp.GetAt(j));
  477. }
  479. //CShape::Draw(pDC);
  480. }
  481. void CPolygon::TopToBottom(CDC* pDC,CRect rect)
  482. {
  483. RefreshData(m_bModified);
  484. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  486. int i=m_flArrayx.GetSize();
  487. for(int j=0;j<i;j++){
  488. m_flArrayy.SetAt(j,rect.top/1000.0+rect.bottom/1000.0-m_flArrayy.GetAt(j));
  489. m_flArrayyTemp.SetAt(j,rect.top/1000.0+rect.bottom/1000.0-m_flArrayyTemp.GetAt(j));
  490. }
  492. //CShape::Draw(pDC);
  493. }
  494. ////////////////////////////////////////////////////////////////////////////
  495. ////////////////////////////////////////////////////////////////////////////
  496. int CPolygon::IsInRect(CRect rect)
  497. {
  498. int nRltVal=0,nTemp;
  499. int i=m_flArrayx.GetSize();
  500. int j=0;
  501. float fx1,fy1,fx2,fy2;
  502. while(++j < i){
  503. fx1=m_flArrayxTemp.GetAt(j-1);
  504. fy1=m_flArrayyTemp.GetAt(j-1);
  505. fx2=m_flArrayxTemp.GetAt(j);
  506. fy2=m_flArrayyTemp.GetAt(j);
  507. nTemp=GetLineStateToRect(fx1,fy1,fx2,fy2,rect);
  508.     nRltVal=nRltVal | nTemp;
  509. }
  510. fx1=m_flArrayxTemp.GetAt(i-1);
  511. fy1=m_flArrayyTemp.GetAt(i-1);
  512. fx2=m_flArrayxTemp.GetAt(0);
  513. fy2=m_flArrayyTemp.GetAt(0);
  514. nTemp=GetLineStateToRect(fx1,fy1,fx2,fy2,rect);
  515. nRltVal=nRltVal | nTemp;
  516. if(nRltVal==3){
  517. nRltVal=1;
  518. }else if(nRltVal==0){
  519. CPoint pt[4];
  520. pt[0].x=rect.left;
  521. pt[0].y=rect.top;
  522. pt[1].x=rect.right;
  523. pt[1].y=rect.top;
  524. pt[2].x=rect.right;
  525. pt[2].y=rect.bottom;
  526. pt[3].x=rect.left;
  527. pt[3].y=rect.bottom;
  528. if(IsPointinRegion(pt[0])&&IsPointinRegion(pt[1])&&
  529. IsPointinRegion(pt[2])&&IsPointinRegion(pt[3])&&
  530. m_nFillStyle==_shape_solid_fill){
  531. nRltVal=1;      
  532. }
  533. }
  534. return nRltVal;
  535. }
  536. CRect CPolygon::GetBoundaryRect()
  537. {
  538. if(m_flArrayxTemp.GetSize()==0){
  539. return CRect(0,0,0,0);
  540. }
  542. CRect rect(1000*m_flArrayxTemp.GetAt(0),1000*m_flArrayyTemp.GetAt(0),1000*m_flArrayxTemp.GetAt(0),1000*m_flArrayyTemp.GetAt(0));
  544. int i=m_flArrayxTemp.GetSize();
  545. int j=0;
  546. float fx,fy;
  547. while(j++<i){
  548. fx=1000*m_flArrayxTemp.GetAt(j-1);
  549. fy=1000*m_flArrayyTemp.GetAt(j-1);
  551. if(fx<rect.left){
  552. rect.left=fx;
  553. }else if(fx>rect.right){
  554. rect.right=fx;
  555. }
  556. if(fy<rect.top){
  557. rect.top=fy;
  558. }else if(fy>rect.bottom){
  559. rect.bottom=fy;
  560. }
  561. }
  563. return rect;
  564. }
  565. CPoint CPolygon::GetCenterPoint()
  566. {
  567. CRect rect=GetBoundaryRect();
  568. return rect.CenterPoint();
  569. }
  570. int CPolygon::IsPointinRegion(POINT point)
  571. {
  572. int nRltVal=0;
  573. int i=m_flArrayx.GetSize();
  574. int j=0;
  575. while(++j < i){
  576.         if(point.y>min(m_flArrayyTemp.GetAt(j-1),m_flArrayyTemp.GetAt(j))&&point.y<max(m_flArrayyTemp.GetAt(j-1),m_flArrayyTemp.GetAt(j)))
  577. {  
  578. if((m_flArrayxTemp.GetAt(j)-(m_flArrayyTemp.GetAt(j)-m_flArrayyTemp.GetAt(j-1))*
  579. ((m_flArrayyTemp.GetAt(j)-point.y)/
  580. (m_flArrayxTemp.GetAt(j)-m_flArrayxTemp.GetAt(j-1)))) >=point.x){
  581. nRltVal+=1;
  582. }
  583. }
  584. }
  585. if(point.y>min(m_flArrayyTemp.GetAt(i-1),m_flArrayyTemp.GetAt(0))&&point.y<max(m_flArrayyTemp.GetAt(i-1),m_flArrayyTemp.GetAt(0)))
  586. {  
  587. if((m_flArrayxTemp.GetAt(0)-(m_flArrayyTemp.GetAt(0)-m_flArrayyTemp.GetAt(i-1))*
  588. ((m_flArrayyTemp.GetAt(0)-point.y)/
  589. (m_flArrayxTemp.GetAt(0)-m_flArrayxTemp.GetAt(i-1)))) >=point.x){
  590. nRltVal+=1;
  591. } }
  592.     if((nRltVal%2)==1){
  593. return 1;
  594.     }
  595. return 0;
  596. }
  597. //////
  598. int CPolygon::GetPtState(float flx,float fly,float flRate){
  599. int nRltVal=0;
  600. int i=m_flArrayx.GetSize();
  601. int j=0;
  602. float x,y;
  603. float tmpx,tmpy;
  604. while(j++<i){
  605. tmpx=m_flArrayxTemp.GetAt(j-1);
  606. tmpy=m_flArrayyTemp.GetAt(j-1);
  607. if(IsPtInRect(tmpx-3*flRate,tmpy-3*flRate,tmpx+3*flRate,tmpy+3*flRate,flx,fly)){
  608. m_nSelectPtNum=j-1;
  609. m_nSelectLineNum=-1;
  610. return 1;
  611. }
  612. }
  613. //on out line
  614. j=0;
  615. while(++j<i){
  617. if(GetPtStateToBigLine(m_flArrayxTemp.GetAt(j-1),m_flArrayyTemp.GetAt(j-1),
  618. m_flArrayxTemp.GetAt(j),m_flArrayyTemp.GetAt(j),5*flRate,flx,fly)){
  619. m_nSelectPtNum=-1;
  620. m_nSelectLineNum=j-1;
  621. return 2;
  622. }
  623. }
  624. if(GetPtStateToBigLine(m_flArrayxTemp.GetAt(i-1),m_flArrayyTemp.GetAt(i-1),
  625. m_flArrayxTemp.GetAt(0),m_flArrayyTemp.GetAt(0),5*flRate,flx,fly)){
  626. m_nSelectPtNum=-1;
  627. m_nSelectLineNum=i-1;
  628. return 2;
  629. }
  630. //out
  632.     m_nSelectPtNum=-1;
  633. m_nSelectLineNum=-1;
  635. return 0;
  636. }
  638. float CPolygon::GetSelectLineRate()
  639. {
  640. if(m_nSelectLineNum==-1)
  641. return 0;
  642. int nptNum= m_flArrayxTemp.GetSize();
  643. float flx1 = m_flArrayx.GetAt((nptNum+m_nSelectLineNum)%nptNum);
  644. float fly1 = m_flArrayy.GetAt((nptNum+m_nSelectLineNum)%nptNum);
  645. float flx2 = m_flArrayx.GetAt((nptNum+m_nSelectLineNum+1)%nptNum);
  646. float fly2 = m_flArrayy.GetAt((nptNum+m_nSelectLineNum+1)%nptNum);
  647. return -GetLineRate(flx1,fly1,flx2,fly2);
  648. }
  650. //////////////////////////////////////////////////////////////////////
  651. // MODULE   :ExPort
  652. // ABSTRACT :Export to a txt file
  653. // FUNCTION :File->Export...
  654. // NOTE     :
  655. // RETURN   :
  656. // ARGUMENTS:
  657. //              I/O           TYPE      NAME       EXPLANATION
  658. //               O            FILE*    outStream    Out put File
  659. // CREATE   :  FNST)handwolf  2004-4-14
  660. // UPDATE   :  
  661. //          : 
  662. //////////////////////////////////////////////////////////////////////
  664. void CPolygon::ExPort(FILE* outStream)//增加导出txt功能时用
  665. {
  666. fprintf(outStream, " CPolygon n");
  667. CShape::ExPort(outStream);
  669. int n=m_flArrayxTemp.GetSize();
  670. int i=0;
  671. fprintf(outStream, "     %d   ",n);
  672. while(i++ < n){
  673. fprintf( outStream, " %f %f",(float)m_flArrayxTemp.GetAt(i-1),(float)m_flArrayyTemp.GetAt(i-1));
  674. }  
  675. fprintf( outStream, "n");
  676. }
  678. //////////////////////////////////////////////////////////////////////
  679. // MODULE   :ImPort
  680. // ABSTRACT :ImPort from a txt file
  681. // FUNCTION :File->ImPort...
  682. // NOTE     :
  683. // RETURN   :
  684. // ARGUMENTS:
  685. //              I/O           TYPE      NAME       EXPLANATION
  686. //               I            FILE*    inStream    in put File
  687. // CREATE   :  FNST)handwolf  2004-4-14
  688. // UPDATE   :  
  689. //          : 
  690. //////////////////////////////////////////////////////////////////////
  691. void CPolygon::ImPort(FILE* inStream)
  692. {
  693. CShape::ImPort(inStream);
  694. float fx,fy;
  695. int n;
  696. fscanf(inStream, "%d",&n);
  697. int i=0;
  698. while(i++ < n){
  699. fscanf(inStream, "%f%f",&fx,&fy);
  700. m_flArrayx.Add(fx);
  701. m_flArrayy.Add(fy);
  702. //temp
  703. m_flArrayxTemp.Add(fx);
  704. m_flArrayyTemp.Add(fy);
  705. }
  706. }
  707. CString CPolygon::GetNameString()
  708. {
  709. CString str;
  710. str.LoadString(IDS_POLYGON);
  711. return str;
  712. }
  713. //////////////////////////////////////////////////////////////////////
  714. //End of File////////////////
  715. ////////////////////////////////////////////////////////////////////////////
  716. ////////////////////////////////////////////////////////////////////////////