object Arx 例 绘制禁止开口带

admin

1. static AcDbObjectId LoadEntity(AcDbEntity* entity)
2. {
5. AcDbBlockTable* pBlockTable;
6. acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlockTable,AcDb::kForRead);
9. AcDbBlockTableRecord* pBlockTableRecord;
10. pBlockTable->getAt(ACDB采用MODEL采用SPACE,pBlockTableRecord,AcDb::kForWrite);
13. AcDbObjectId Id;
14. pBlockTableRecord->appendAcDbEntity(Id,entity);
17. pBlockTable->close();
18. pBlockTableRecord->close();
21. entity->close();
22. return Id;
23. }
26. static void SetLineWeight(double& weight,bool& isCancel)
27. {
28. CString str;
29. str.Format(采用T("\n禁止开口带线宽: <%.2f>"),weight);
32. acedInitGet(RSG采用NONEG+RSG采用NOZERO,NULL);
33. int ret = acedGetReal(str,&weight);
34. if(ret == RTCAN)
35. {
36. isCancel = true;
37. }
38. else
39. {
40. isCancel = false;
41. }
42. }
44. static void TESTcornercmd()
45. {
46. //设置线宽-----------------------------------
47. bool isCan = false;
48. ads采用real lineWeight = DEFAULT采用WEIGHT;
49. SetLineWeight(lineWeight,isCan);
50. if(isCan)
51. {
52. return;
53. }
56. //选择一点-----------------------------------
59. ads采用point ptCorner;
60. while(true)
61. {
62. acedInitGet(RSG采用NONULL,采用T("S"));
63. int retPt = acedGetPoint(NULL,采用T("\n点选地块转角[设置线宽(S)]:"),ptCorner);
64. if(retPt == RTNORM)
65. {
66. break;
67. }
68. else if(retPt == RTKWORD)
69. {
70. CString strInput;
71. acedGetInput(strInput.GetBuffer(10));
72. strInput.ReleaseBuffer();
73. if(strInput.CompareNoCase(采用T("S")) == 0)
74. {
75. SetLineWeight(lineWeight,isCan);
76. if(isCan)
77. {
78. return;
79. }
80. }
81. }
82. else
83. {
84. return;
85. }
86. }
87. AcGePoint3d ptCorner3d = asPnt3d(ptCorner);
90. //设置过滤器--------------------------------------
91. resbuf* strFilter = NULL;
92. strFilter = acutBuildList(-4,采用T("<and"),
93. -4,采用T("<or"),
94. 8,采用T("C1"),//C1层
95. 8,采用T("C2"),//C2层
96. 8,采用T("C3"),//C3层
97. 8,采用T("R2"),//R2层
98. -4,采用T("or>"),
99. RTDXF0,采用T("LWPOLYLINE"),///多段线
100. -4,采用T("and>"),
101. RTNONE);
104. ads采用name ssName;
105. if(acedSSGet(采用T("X"),NULL,NULL,strFilter,ssName) != RTNORM)
106. {
107. acutPrintf(采用T("\n未找到符合条件的图形"));
108. acutRelRb(strFilter);
109. return;
110. }
113. long len = 0;
114. acedSSLength(ssName,&len);
115. if(len <=0)
116. {
117. acutPrintf(采用T("\n图形数量是0"));
118. acedSSFree(ssName);
119. acutRelRb(strFilter);
120. return;
121. }
124. //遍历选择集，找到距离点击位置最近的线段，计算出相邻线段的单位向量----------------------------------
125. ads采用name en;
126. AcDbObjectId eId;
127. AcDbPolyline* plMin = NULL;
128. int plIndex = 0;
129. AcDbPolyline::SegType segType;
132. AcGePoint3d ptClosest;
133. AcGePoint3d ptMinClose;
134. double minDist = 0.0;
137. for(int i = 0;i < len;i++)
138. {
141. int rName = acedSSName(ssName,i,en);
142. if(rName != RTNORM)
143. {
144. acutPrintf(采用T("\n获取名称失败"));
145. continue;
146. }
149. Acad::ErrorStatus es = acdbGetObjectId(eId,en);
150. if(es!=Acad::eOk)
151. {
152. acutPrintf(采用T("\n获取ID失败"));
153. continue;
154. }
155. AcDbEntity* pEnt = NULL;
157. es = acdbOpenObject(pEnt,eId,AcDb::OpenMode::kForRead);
158. if(es != Acad::eOk)
159. {
160. acutPrintf(采用T("\n打开实体失败"));
161. continue;
162. }
165. if(!pEnt->isKindOf(AcDbPolyline::desc()))
166. {
167. acutPrintf(采用T("\n第%d个实体不是多段线"),i);
168. pEnt->close();
169. continue;
170. }
173. AcDbPolyline* pPoly = NULL;
174. pPoly = (AcDbPolyline*)pEnt;
177. es = pPoly->getClosestPointTo(ptCorner3d,ptClosest);
178. if(es != Acad::eOk)
179. {
180. acutPrintf(采用T("\n获取最小距离点出错"));
181. pEnt->close();
182. continue;
183. }
186. double minParam = 0.0;
187. es = pPoly->getParamAtPoint(ptClosest,minParam);
188. if(es != Acad::eOk)
189. {
190. pEnt->close();
191. continue;
192. }
195. double dist = ptCorner3d.distanceTo(ptClosest);
196. if(i == 0)
197. {
198. minDist = dist;
199. }
201. else if(dist >= minDist && i > 0)
202. {
203. pEnt->close();
204. continue;
205. }
208. minDist = dist;
209. AcDbPolyline::SegType st = pPoly->segType(minParam);
210. if(st == AcDbPolyline::SegType::kArc)
211. {
212. AcGeCircArc3d arc3d;
213. pPoly->getArcSegAt(minParam,arc3d);
216. segType = st;
217. plMin = AcDbPolyline::cast(pPoly->clone());
218. plIndex = minParam;
219. ptMinClose = ptClosest;
222. }
223. else if(st == AcDbPolyline::SegType::kLine)
224. {
225. AcGeLineSeg3d line3d;
226. pPoly->getLineSegAt(minParam,line3d);
229. segType = st;
230. plMin = AcDbPolyline::cast(pPoly->clone());
231. plIndex = minParam;
232. ptMinClose = ptClosest;
235. }
236. pEnt->close();
237. }
240. //释放资源-------------------------------------------
241. //pEnt->close();
242. acutRelRb(strFilter);
243. acedSSFree(ssName);
246. //判断最小距离是否超出了系统允许的最大值
247. if(minDist >MINDISTANCE)
248. {
249. acutPrintf(采用T("\n最小距离至少为%.2f"),MINDISTANCE);
250. delete plMin;
251. return;
252. }
255. //绘制转角线段-------------------------------------------------
256. AcDbPolyline * pLine = new AcDbPolyline();
258. 线段
259. if(segType == AcDbPolyline::SegType::kLine)
260. {
261. AcGeLineSeg2d line2d;
262. plMin->getLineSegAt(plIndex,line2d);
265. pLine->addVertexAt(0,line2d.startPoint());
266. pLine->addVertexAt(1,line2d.endPoint());
267. }
268. 弧
269. else if(segType == AcDbPolyline::SegType::kArc)
270. {
271. AcGeCircArc2d arc2d;
272. plMin->getArcSegAt(plIndex,arc2d);
273. double bulge = 0.0;
274. plMin->getBulgeAt(plIndex,bulge);
277. pLine->addVertexAt(0,arc2d.startPoint(),bulge);
278. pLine->addVertexAt(1,arc2d.endPoint());
279. }
282. Acad::ErrorStatus es = pLine->setLayer(strLayer);
283. if(Acad::eOk != es)
284. {
285. acutPrintf(采用T("\n设置层名称出错"));
286. }
289. es = pLine->setConstantWidth(lineWeight);
290. if(Acad::eOk != es)
291. {
292. acutPrintf(采用T("\n设置曲线宽度出错"));
293. }
296. AcDbObjectIdArray idArr;
297. AcDbObjectId idLine = LoadEntity(pLine);
298. idArr.append(idLine);记录ObjId
301. //绘制禁止开口两边-------------------------
304. 第一个邻边
305. //--------------箭头-----------------------
307. AcGePoint3d pt3dS;
308. AcGePoint3d pt3dE;
309. AcGePoint2d pt2dS;
310. AcGePoint2d pt2dE;
312. bool gotonext = true;
313. if(segType == AcDbPolyline::SegType::kArc)
314. {
315. AcGeCircArc3d arc3d;
316. plMin->getArcSegAt(plIndex,arc3d);
317. AcGeCircArc2d arc2d;
318. plMin->getArcSegAt(plIndex,arc2d);
319. pt3dS = arc3d.startPoint();
320. pt3dE = arc3d.endPoint();
321. pt2dS = arc2d.startPoint();
322. pt2dE = arc2d.endPoint();
325. }
326. else
327. {
328. AcGeLineSeg3d line3d;
329. plMin->getLineSegAt(plIndex,line3d);
330. AcGeLineSeg2d line2d;
331. plMin->getLineSegAt(plIndex,line2d);
334. pt3dS = line3d.startPoint();
335. pt3dE = line3d.endPoint();
336. pt2dS = line2d.startPoint();
337. pt2dE = line2d.endPoint();
338. }
341. AcDbObjectId idPointer1;
342. DrawPointer(plMin,!gotonext,plIndex,pt3dS,idPointer1);
345. ads采用real dis=DEFAULT采用LEN;
348. acedInitGet(RSG采用NOZERO+RSG采用NONEG,采用T("P"));
349. CString strDis ;
350. strDis.Format(采用T("\n输入该方向的禁止开口长度[从点击位置算起(P)]<%.2f>:"),dis);
351. int ret = acedGetReal(strDis,&dis);
354. int polyIndex = 0;
355. if(ret == RTCAN)
356. {
357. EraseIds(idArr);
358. RemoveEntity(idPointer1);
359. delete plMin;
360. return;
361. }
363. else if(ret == RTKWORD)
364. {
365. CString str;
366. acedGetInput(str.GetBuffer(2));
367. str.ReleaseBuffer();
368. double length = 0.0;
369. EraseIds(idArr);
370. if(str.CompareNoCase(采用T("P")) == 0)
371. {
372. AcDbObjectIdArray pIdArr;
375. strDis.Format(采用T("\n输入该方向的禁止开口长度<%.2f>:"),dis);
376. acedInitGet(RSG采用NOZERO+RSG采用NONEG,NULL);
377. ret = acedGetReal(strDis,&dis);
378. if(ret == RTCAN)
379. {
380. RemoveEntity(idPointer1);
381. delete plMin;
382. return;
383. }
385. double disS = 0.0;
386. double disE = 0.0;
387. double disC = 0.0;
388. plMin->getDistAtPoint(ptMinClose,disC);
389. plMin->getDistAtPoint(pt3dS,disS);
390. plMin->getDistAtPoint(pt3dE,disE);
393. AcGePoint2d ptClose2d;
394. Pt3dTo2d(ptMinClose,ptClose2d);
395. double curBulge = 0.0;
396. plMin->getBulgeAt(plIndex,curBulge);
399. 向前面画
400. length = abs(disS - disC);
402. AcDbPolyline* pl1 = new AcDbPolyline();
403. pl1->setConstantWidth(lineWeight);
404. pl1->setLayer(strLayer);
405. int pl1Index = 0;
407. StartWithP(plMin,plIndex,dis,length,segType,ptClose2d,!gotonext,pl1,pl1Index);
410. AcDbObjectId idPl1 = LoadEntity(pl1);
411. pIdArr.append(idPl1);
412. 移除第1个箭头
413. RemoveEntity(idPointer1);
416. --------------------向后面画--先画箭头------------------------
417. AcDbObjectId idPointer2;
418. DrawPointer(plMin,gotonext,plIndex,pt3dE,idPointer2);
420. int count = plMin->numVerts();
423. AcDbPolyline* pl2 = new AcDbPolyline();
424. pl2->setConstantWidth(lineWeight);
425. pl2->setLayer(strLayer);
426. int pl2Index = 0;
427. if(plIndex == count - 1)
428. {
429. double total = 0.0;
430. double endParam = 0.0;
431. plMin->getEndParam(endParam);
432. plMin->getDistAtParam(endParam,total);
433. disE = total;
434. }
435. length = abs(disC - disE);
438. strDis.Format(采用T("\n输入该方向的禁止开口长度<%.2f>:"),dis);
439. acedInitGet(RSG采用NOZERO+RSG采用NONEG,NULL);
440. ret = acedGetReal(strDis,&dis);
441. if(ret == RTCAN)
442. {
443. delete plMin;
444. RemoveEntity(idPointer2);
445. EraseIds(pIdArr);
446. return;
447. }
449. StartWithP(plMin,plIndex,dis,length,segType,ptClose2d,gotonext,pl2,pl2Index);
452. AcDbObjectId idPl2 = LoadEntity(pl2);
453. pIdArr.append(idPl2);
455. 移除第二个箭头
456. RemoveEntity(idPointer2);
460. AcDbPolyline* plAll = new AcDbPolyline();
461. plAll->setConstantWidth(lineWeight);
462. plAll->setLayer(strLayer);
464. int plAllIndex = 0;
465. AppendPLinePoint(idPl1,!gotonext,plAll,plAllIndex);
466. AppendPLinePoint(idPl2,gotonext,plAll,plAllIndex);
467. LoadEntity(plAll);
470. EraseIds(pIdArr);
471. }
474. delete plMin;
475. return;
476. }
477. //不是点击位置开始的情况------------------------------------
481. //第一条边
483. AcDbPolyline* pLine1 = new AcDbPolyline();
484. pLine1->setConstantWidth(lineWeight);
485. pLine1->setLayer(strLayer);
486. int pLine1Index = 0;
487. AcGePoint2d ptNextS;
488. AcGePoint2d ptNextE;
489. GetNextPt(plMin,!gotonext,plIndex,ptNextS,ptNextE);
492. DrawByLen(!gotonext,ptNextE,ptNextS,dis,plMin,pLine1,pLine1Index);
494. AcDbObjectId idLine1 = LoadEntity(pLine1);
495. idArr.append(idLine1);
496. RemoveEntity(idPointer1);
498. //第二条边
500. strDis.Format(采用T("\n输入该方向的禁止开口长度<%.2f>:"),dis);
501. acedInitGet(RSG采用NOZERO+RSG采用NONEG,NULL);
502. ret = acedGetReal(strDis,&dis);
503. if(ret == RTCAN)
504. {
505. delete plMin;
506. EraseIds(idArr);
507. return;
508. }
511. AcDbObjectId idPointer2;
512. DrawPointer(plMin,gotonext,plIndex,pt3dE,idPointer2);
515. AcDbPolyline* pLine2 = new AcDbPolyline();
516. pLine2->setConstantWidth(lineWeight);
517. pLine2->setLayer(strLayer);
520. int pLine2Index = 0;
521. GetNextPt(plMin,gotonext,plIndex,ptNextS,ptNextE);
522. DrawByLen(gotonext,ptNextS,ptNextE,dis,plMin,pLine2,pLine2Index);
523. AcDbObjectId idLine2 = LoadEntity(pLine2);
526. idArr.append(idLine2);
527. RemoveEntity(idPointer2);
528. delete plMin;
531. //合并多段线----------------------------------------
532. AcDbPolyline* pl = new AcDbPolyline();
533. pl->setConstantWidth(lineWeight);
534. pl->setLayer(strLayer);
535. int plIndex1 = 0;
536. AppendPLinePoint(idLine1,false,pl,plIndex1);
537. AppendPLinePoint(idLine,true,pl,plIndex1);
538. AppendPLinePoint(idLine2,true,pl,plIndex1);
541. LoadEntity(pl);
544. //移除之前画上去的3条多段线
545. EraseIds(idArr);
547. }
550. static void StartWithP(const AcDbPolyline* plMin,const int& plIndex,const double& dis,
551. const double& length,const AcDbPolyline::SegType& segType,const AcGePoint2d& ptClose2d,const bool& gotonext,AcDbPolyline* pl1,int& pl1Index)
552. {
553. AcGePoint2d ptS;
554. AcGePoint2d ptE;
555. double curBulge = 0.0;
556. plMin->getBulgeAt(plIndex,curBulge);
557. double thisLen = 0.0;
560. if(segType == AcDbPolyline::SegType::kArc)
561. {
562. AcGeCircArc2d arc2d;
563. plMin->getArcSegAt(plIndex,arc2d);
564. ptS = arc2d.startPoint();
565. ptE = arc2d.endPoint();
566. thisLen = arc2d.length(arc2d.paramOf(ptS),arc2d.paramOf(ptE));
567. }
568. else
569. {
570. AcGeLineSeg2d line2d;
571. plMin->getLineSegAt(plIndex,line2d);
572. ptS = line2d.startPoint();
573. ptE = line2d.endPoint();
574. }
579. if(dis > length)
580. {
581. double bulge1 = 0.0;
582. if(segType == AcDbPolyline::SegType::kArc)
583. {
584. bulge1 = tan(atan(curBulge) * length / thisLen);
585. }
587. if(!gotonext)
588. {
589. pl1->addVertexAt(pl1Index,ptClose2d,-bulge1);
590. pl1Index++;
591. pl1->addVertexAt(pl1Index,ptS);
592. pl1Index ++;
593. }
594. else
595. {
596. pl1->addVertexAt(pl1Index,ptClose2d,bulge1);
597. pl1Index++;
598. pl1->addVertexAt(pl1Index,ptE);
599. pl1Index ++;
600. }
603. AcGePoint2d ptNextS;
604. AcGePoint2d ptNextE;
605. GetNextPt(plMin,gotonext,plIndex,ptNextS,ptNextE);
608. DrawByLen(gotonext,ptNextS,ptNextE,dis-length,plMin,pl1,pl1Index);
609. }
610. else
611. {
612. AcGePoint2d ptEnding;
613. if(segType == AcDbPolyline::SegType::kArc)
614. {
615. AcGeCircArc2d arc2d;
616. plMin->getArcSegAt(plIndex,arc2d);
617. if(!gotonext)
618. {
619. GetPtAtDistOnCurve(&arc2d,ptClose2d,dis,ptEnding,Adesk::kFalse);
620. }
621. else
622. {
623. GetPtAtDistOnCurve(&arc2d,ptClose2d,dis,ptEnding,Adesk::kTrue);
624. }
625. }
626. else
627. {
628. AcGeLineSeg2d line2d;
629. plMin->getLineSegAt(plIndex,line2d);
631. if(!gotonext)
632. {
633. GetPtAtDistOnCurve(&line2d,ptClose2d,dis,ptEnding,Adesk::kFalse);
634. }
635. else
636. {
637. GetPtAtDistOnCurve(&line2d,ptClose2d,dis,ptEnding,Adesk::kTrue);
638. }
639. }
642. double bulge1 = 0.0;
643. if(segType == AcDbPolyline::SegType::kArc)
644. {
645. bulge1 = tan(atan(curBulge) * dis / thisLen);
646. }
649. if(!gotonext)
650. {
651. pl1->addVertexAt(pl1Index,ptClose2d,-bulge1);
652. }
653. else
654. {
655. pl1->addVertexAt(pl1Index,ptClose2d,bulge1);
656. }
657. pl1Index++;
658. pl1->addVertexAt(pl1Index,ptEnding);
659. }
661. }
664. static void GetNextPt(const AcDbPolyline* plMin,const bool& gotonext,const int& plIndex,AcGePoint2d& ptNextS,AcGePoint2d& ptNextE)
665. {
666. int nextIndex = 0;
667. int count = plMin->numVerts();
668. if(!gotonext)
669. {
670. if(plIndex > 0)
671. {
672. nextIndex = plIndex - 1;
673. }
674. else
675. {
676. nextIndex = count - 1;
677. }
678. }
679. else
680. {
681. if(plIndex < count - 1)
682. {
683. nextIndex = plIndex + 1;
684. }
685. else
686. {
687. nextIndex = 0;
688. }
689. }
692. AcDbPolyline::SegType nextType = plMin->segType(nextIndex);
695. if(nextType == AcDbPolyline::SegType::kArc)
696. {
697. AcGeCircArc2d arc2d;
698. plMin->getArcSegAt(nextIndex,arc2d);
699. ptNextS = arc2d.startPoint();
700. ptNextE = arc2d.endPoint();
701. }
702. else
703. {
704. AcGeLineSeg2d line2d;
705. plMin->getLineSegAt(nextIndex,line2d);
706. ptNextS = line2d.startPoint();
707. ptNextE = line2d.endPoint();
708. }
711. }
714. 合成多段线
715. static void AppendPLinePoint(const AcDbObjectId& id,const bool& gotoNext,AcDbPolyline* pLine,int& plIndex)
716. {
717. AcDbEntity* pEnt = NULL;
718. Acad::ErrorStatus es = acdbOpenObject(pEnt,id,AcDb::OpenMode::kForRead);
719. if(es != Acad::eOk)
720. {
721. acutPrintf(采用T("open object failed in combine pline"));
722. return;
723. }
724. if(!pEnt->isKindOf(AcDbPolyline::desc()))
725. {
726. pEnt->close();
727. return;
728. }
730. AcDbPolyline* pPoly = NULL;
731. pPoly = (AcDbPolyline*)pEnt;
732. AcGePoint2dArray ptArr;
733. int count = pPoly->numVerts();
734. AcGePoint2d pt ;
735. double bulge = 0.0;
736. if(gotoNext)
737. {
738. for(int i = 0;i < count ; i++)
739. {
740. pPoly->getPointAt(i,pt);
741. pPoly->getBulgeAt(i,bulge);
742. pLine->addVertexAt(plIndex,pt,bulge);
743. plIndex++;
744. }
745. }
746. else
747. {
748. for(int i = count - 1;i > 0; i--)
749. {
750. pPoly->getPointAt(i,pt);
751. if(i > 0)
752. {
753. pPoly->getBulgeAt(i - 1,bulge);
754. }
755. else
756. {
757. pPoly->getBulgeAt(0,bulge);
758. }
759. pLine->addVertexAt(plIndex,pt,-bulge);
760. plIndex++;
761. }
762. }
764. pEnt->close();
765. }
768. static void EraseIds(AcDbObjectIdArray idArr)
769. {
770. if(idArr == NULL || idArr.length() == 0)
771. {
772. return;
773. }
774. for(int i = 0;i < idArr.length(); i++)
775. {
776. AcDbEntity* pDel = NULL;
777. if(Acad::eOk != acdbOpenObject(pDel,idArr.at(i),AcDb::OpenMode::kForWrite))
778. {
779. continue;
780. }
781. if(Acad::eOk != pDel->erase())
782. {
783. acutPrintf(采用T("\n删除第%d个实体失败"),i);
784. }
785. pDel->close();
786. }
787. }
790. 绘制箭头(ptStart 为转角线段的起点)
791. static void DrawPointer(const AcDbPolyline* pl,bool gotonext,const int& plIndex,const AcGePoint3d& ptDraw,AcDbObjectId& idPointer)
792. {
793. //--当前边相关信息
794. AcGePoint3d ptCurStart;
795. AcGePoint3d ptCurEnd;
796. AcGeCircArc3d arc3dCur;
797. AcGeLineSeg3d line3dCur;
800. AcDbPolyline::SegType curType = pl->segType(plIndex);
801. if(curType == AcDbPolyline::SegType::kArc)
802. {
803. pl->getArcSegAt(plIndex,arc3dCur);
804. ptCurStart = arc3dCur.startPoint();
805. ptCurEnd = arc3dCur.endPoint();
806. }
807. else
808. {
809. pl->getLineSegAt(plIndex,line3dCur);
810. ptCurStart = line3dCur.startPoint();
811. ptCurEnd = line3dCur.endPoint();
812. }
814. double paramDraw = 0.0;
815. if(pl->getParamAtPoint(ptDraw,paramDraw)!=Acad::eOk)
816. {
817. return;
818. }
819. AcGeVector3d v3d;
820. pl->getFirstDeriv(paramDraw,v3d);
821. AcGeVector2d v(v3d[X],v3d[Y]);
822. AcGePoint2d pt0(ptDraw[X],ptDraw[Y]);
824. v.normalize();
825. if(!gotonext)
826. {
827. v = -v;
828. }
829. AcGeVector2d vVer = v;
830. 绘制箭头
831. AcDbPolyline* pLine = new AcDbPolyline();
832. pLine->addVertexAt(0,pt0);
835. vVer.rotateBy(PI/2);
836. AcGePoint2d pt1 = pt0 + vVer *POINTERWIDTH / 2;
837. pLine->addVertexAt(1,pt1);
840. vVer.rotateBy(-PI/2);
841. AcGePoint2d pt2 = pt1 + vVer * POINTERLENGTH;
842. pLine->addVertexAt(2,pt2);
845. vVer.rotateBy(PI/2);
846. AcGePoint2d pt3 = pt2 + vVer * POINTERWIDTH / 2;
847. pLine->addVertexAt(3,pt3);
850. vVer.rotateBy(- 3 * PI/4);
851. AcGePoint2d pt4 = pt3 + vVer * sqrt(2.0) * POINTERWIDTH;
852. pLine->addVertexAt(4,pt4);
855. vVer.rotateBy(-PI/2);
856. AcGePoint2d pt5 = pt4 + vVer * sqrt(2.0) * POINTERWIDTH;
857. pLine->addVertexAt(5,pt5);
860. vVer.rotateBy(-3 * PI/4);
861. AcGePoint2d pt6 = pt5 + vVer * POINTERWIDTH / 2;
862. pLine->addVertexAt(6,pt6);
865. vVer.rotateBy(PI/2);
866. AcGePoint2d pt7 = pt6 + vVer * POINTERLENGTH ;
867. pLine->addVertexAt(7,pt7);
870. vVer.rotateBy(-PI/2);
871. AcGePoint2d pt8 = pt7 + vVer * POINTERWIDTH / 2;
872. pLine->addVertexAt(8,pt8);
873. idPointer = LoadEntity(pLine);
874. }
877. static void RemoveEntity(AcDbObjectId entId)
878. {
879. AcDbEntity* pEnt = NULL;
880. if(acdbOpenObject(pEnt,entId,AcDb::OpenMode::kForWrite) == Acad::eOk)
881. {
882. if(pEnt->erase() != Acad::eOk)
883. {
884. acutPrintf(采用T("\n移除对象失败"));
885. return;
886. }
887. }
888. else
889. {
890. acutPrintf(采用T("\n打开对象失败"));
891. }
892. pEnt->close();
893. }
895. 2d坐标转为3d
896. static void Pt2dTo3d(AcGePoint2d& pt2d,AcGePoint3d& pt3d)
897. {
898. pt3d[X] = pt2d[X];
899. pt3d[Y] = pt2d[Y];
900. pt3d[Z] = 0;
901. }
904. 3d坐标转化为X,Y轴上的2D坐标
905. static void Pt3dTo2d(const AcGePoint3d& pt3d,AcGePoint2d& pt2d)
906. {
907. pt2d = pt3d.convert2d(AcGePlane(AcGePoint3d::kOrigin, AcGeVector3d(0,0, 1)));
908. }
911. //from:起点，to:终点（这两点要相邻）
912. //paramDis:沿着多段线画多长
913. //pl:多段线
914. //pPoly:新的多段线
915. static void DrawByLen(const bool& gotoNext ,const AcGePoint2d& from,const AcGePoint2d& to,const double& paramDis,const AcDbPolyline* pl,AcDbPolyline* pPoly,int& polyIndex)
916. {
917. if(paramDis <= 0)
918. {
919. return;
920. }
921. int len = pl->numVerts();
923. AcGeCircArc2d arc2d;
924. AcGeLineSeg2d line2d;
927. AcGePoint2d ptS;
928. AcGePoint2d ptE;
929. bool isFind = false;
930. int plIndex = 0;
931. AcGeCurve2d* pCurve = NULL;
933. for(int i = 0;i < len;i++)
934. {
935. AcDbPolyline::SegType st = pl->segType(i);
937. if(st == AcDbPolyline::SegType::kArc)
938. {
939. pl->getArcSegAt(i,arc2d);
940. pCurve = &arc2d;
941. }
942. else if(st == AcDbPolyline::SegType::kLine)
943. {
944. pl->getLineSegAt(i,line2d);
945. pCurve = &line2d;
946. }
949. if(!pCurve->hasStartPoint(ptS) || !pCurve->hasEndPoint(ptE))
950. {
951. continue;
952. }
954. if(ptS == from && ptE == to || ptS == to && ptE == from)
955. {
956. plIndex = i;
957. isFind = true;
958. break;
959. }
960. }
963. double sumDis = 0.0;
964. if(isFind)
965. {
966. DrawIt(gotoNext,pl,paramDis,from,polyIndex,plIndex,sumDis,pPoly);
967. }
968. else
969. {
970. acutPrintf(采用T("\nnot found"));
971. }
972. }
975. //summary
976. //指定一个起点和一条多段线，沿着多段线画出指定距离，递归执行，每次往后（前）移动一个点，直到画完指定的距离，
977. //pl:多段线
978. //paramDis:画多长
979. //ptStart:起始点
980. //polyIndex:添加到第几个了
981. //plIndex，遍历到多段线第几条线
982. //isSToE，遍历的顺序1：从前向后  0：从后向前
983. //sumDis，目前画的总长度
984. //pPoly:画出来的多段线
985. static void DrawIt(const bool& gotoNext,const AcDbPolyline* pl,const double& paramDis,const AcGePoint2d& ptStart,int& polyIndex,int& plIndex,double& sumDis,AcDbPolyline* pPoly)
986. {
988. AcDbPolyline::SegType st = pl->segType(plIndex);
989. AcGePoint2d ptS;
990. AcGePoint2d ptE;
991. double leftDis = 0.0;
992. double curveDis = 0.0;
993. double bulge = 0.0;
994. AcGeCurve2d* pCurve = NULL;
995. AcGeCircArc2d arc2d;
996. AcGeLineSeg2d line2d;
997. int len = pl->numVerts();
1000. if(polyIndex == 2*(len - 2))
1001. {
1002. acutPrintf(采用T("\nend poly is %d"),polyIndex);
1003. return;
1004. }
1007. if(st == AcDbPolyline::SegType::kArc)
1008. {
1009. pl->getArcSegAt(plIndex,arc2d);
1010. pCurve = &arc2d;！！！注意：指针的生命周期一定要大于等于指向的变量的生命周期，否则变量release掉指针就空了，再次使用指针程序直接崩溃！！
1011. }
1012. else if(st == AcDbPolyline::SegType::kLine)
1013. {
1014. pl->getLineSegAt(plIndex,line2d);
1015. pCurve = &line2d;
1016. }
1017. if(!pCurve->hasStartPoint(ptS) || !pCurve->hasEndPoint(ptE))
1018. {
1019. return;
1020. }
1021. curveDis = pCurve->length(pCurve->paramOf(ptS),pCurve->paramOf(ptE));
1022. leftDis = paramDis - sumDis;
1025. pl->getBulgeAt(plIndex,bulge);
1028. if(curveDis > leftDis)
1029. {
1030. double paramEnding = 0.0;
1032. if(gotoNext)
1033. {
1034. AcGePoint2d ptEnding;
1035. AcGePoint2d ptS;
1036. pCurve->hasStartPoint(ptS);
1037. GetPtAtDistOnCurve(pCurve,ptS,leftDis,ptEnding,Adesk::kTrue);
1040. bulge = tan(atan(bulge) * leftDis/curveDis);
1043. pPoly->addVertexAt(polyIndex,ptS,bulge);
1044. polyIndex ++;
1045. pPoly->addVertexAt(polyIndex,ptEnding);
1046. }
1047. else
1048. {
1049. AcGePoint2d ptEnding;
1052. AcGePoint2d ptE;
1053. pCurve->hasEndPoint(ptE);
1054. GetPtAtDistOnCurve(pCurve,ptE,leftDis,ptEnding,Adesk::kFalse);
1057. bulge = tan(atan(bulge) * leftDis/curveDis);
1060. pPoly->addVertexAt(polyIndex,ptE,-bulge);
1061. polyIndex ++;
1062. pPoly->addVertexAt(polyIndex,ptEnding);
1063. }
1064. return;
1065. }
1066. else
1067. {
1068. if(gotoNext)
1069. {
1070. pPoly->addVertexAt(polyIndex,ptS,bulge);
1071. polyIndex ++;
1072. pPoly->addVertexAt(polyIndex,ptE);
1073. polyIndex ++;
1074. //acutPrintf(采用T("\nplIndex is %d,poly is %d。is goto next,bulge is %.2f"),plIndex,polyIndex,bulge);
1075. }
1076. else
1077. {
1078. pPoly->addVertexAt(polyIndex,ptE,-bulge);
1079. polyIndex ++;
1080. pPoly->addVertexAt(polyIndex,ptS);
1081. polyIndex ++;
1083. }
1084. /*acutPrintf(采用T("\nptS[X] :%.2f,ptS[Y]:%.2f,ptE[X]:%.2f,ptE[Y]:%.2f"),ptS[X],ptS[Y],ptE[X],ptE[Y]);*/
1085. sumDis += curveDis;
1087. }
1090. if(gotoNext)
1091. {
1092. plIndex = plIndex < len - 1  ? ++plIndex : 0;
1093. }
1094. else
1095. {
1096. plIndex = plIndex > 0 ? --plIndex : len - 1;
1097. }
1100. DrawIt(gotoNext,pl,paramDis,ptStart,polyIndex,plIndex,sumDis,pPoly);
1103. }
1105. 反回曲线上一定距离的点（默认从起点开始计算）
1106. pCurve:曲线指针，dist：距离，point：要返回的点
1107. Adesk::Boolean isGotoNext  true:沿着正向寻找，false：沿着反方向寻找
1108. static void GetPtAtDistOnCurve(const AcGeCurve2d* pCurve,const AcGePoint2d& ptInput,double dist,AcGePoint2d& point,Adesk::Boolean isGotoNext)
1109. {
1110. if(pCurve == NULL)
1111. {
1112. return;
1113. }
1114. AcGePoint2d ptS;
1115. ptS = ptInput;
1116. double pa = 0.0;
1117. double datumParam = 0.0;
1118. //Adesk::Boolean posParamDir = Adesk::kTrue;
1120. datumParam = pCurve->paramOf(ptS);
1121. pa = pCurve->paramAtLength(datumParam,dist,isGotoNext);
1122. point = pCurve->evalPoint(pa);
1123. }

复制代码