哪位大侠帮我弄成CAD可执行的程序，谢谢！

shuaier

编好后发到我的邮箱414528096@qq.com，非常感谢！

1. static AcDbObjectId LoadEntity(AcDbEntity* entity)
   
2. {
   
3. 
   
4. 
   
5. AcDbBlockTable* pBlockTable;
   
6. acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlockTable,AcDb::kForRead);
   
7. 
   
8. 
   
9. AcDbBlockTableRecord* pBlockTableRecord;
   
10. pBlockTable->getAt(ACDB_MODEL_SPACE,pBlockTableRecord,AcDb::kForWrite);
    
11. 
    
12. 
    
13. AcDbObjectId Id;
    
14. pBlockTableRecord->appendAcDbEntity(Id,entity);
    
15. 
    
16. 
    
17. pBlockTable->close();
    
18. pBlockTableRecord->close();
    
19. 
    
20. 
    
21. entity->close();
    
22. return Id;
    
23. }
    
24. 
    
25. 
    
26. static void SetLineWeight(double& weight,bool& isCancel)
    
27. {
    
28. CString str;
    
29. str.Format(_T("\n禁止开口带线宽: <%.2f>"),weight);
    
30. 
    
31. 
    
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. }
    
43. 
    
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. }
    
54. 
    
55. 
    
56. //选择一点-----------------------------------
    
57. 
    
58. 
    
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);
    
88. 
    
89. 
    
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);
     
102. 
     
103. 
     
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. }
     
111. 
     
112. 
     
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. }
     
122. 
     
123. 
     
124. //遍历选择集，找到距离点击位置最近的线段，计算出相邻线段的单位向量----------------------------------
     
125. ads_name en;
     
126. AcDbObjectId eId;
     
127. AcDbPolyline* plMin = NULL;
     
128. int plIndex = 0;
     
129. AcDbPolyline::SegType segType;
     
130. 
     
131. 
     
132. AcGePoint3d ptClosest;
     
133. AcGePoint3d ptMinClose;
     
134. double minDist = 0.0;
     
135. 
     
136. 
     
137. for(int i = 0;i < len;i++)
     
138. {
     
139. 
     
140. 
     
141. int rName = acedSSName(ssName,i,en);
     
142. if(rName != RTNORM)
     
143. {
     
144. acutPrintf(_T("\n获取名称失败"));
     
145. continue;
     
146. }
     
147. 
     
148. 
     
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;
     
156. 
     
157. es = acdbOpenObject(pEnt,eId,AcDb::OpenMode::kForRead);
     
158. if(es != Acad::eOk)
     
159. {
     
160. acutPrintf(_T("\n打开实体失败"));
     
161. continue;
     
162. }
     
163. 
     
164. 
     
165. if(!pEnt->isKindOf(AcDbPolyline::desc()))
     
166. {
     
167. acutPrintf(_T("\n第%d个实体不是多段线"),i);
     
168. pEnt->close();
     
169. continue;
     
170. }
     
171. 
     
172. 
     
173. AcDbPolyline* pPoly = NULL;
     
174. pPoly = (AcDbPolyline*)pEnt;
     
175. 
     
176. 
     
177. es = pPoly->getClosestPointTo(ptCorner3d,ptClosest);
     
178. if(es != Acad::eOk)
     
179. {
     
180. acutPrintf(_T("\n获取最小距离点出错"));
     
181. pEnt->close();
     
182. continue;
     
183. }
     
184. 
     
185. 
     
186. double minParam = 0.0;
     
187. es = pPoly->getParamAtPoint(ptClosest,minParam);
     
188. if(es != Acad::eOk)
     
189. {
     
190. pEnt->close();
     
191. continue;
     
192. }
     
193. 
     
194. 
     
195. double dist = ptCorner3d.distanceTo(ptClosest);
     
196. if(i == 0)
     
197. {
     
198. minDist = dist;
     
199. }
     
200. 
     
201. else if(dist >= minDist && i > 0)
     
202. {
     
203. pEnt->close();
     
204. continue;
     
205. }
     
206. 
     
207. 
     
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);
     
214. 
     
215. 
     
216. segType = st;
     
217. plMin = AcDbPolyline::cast(pPoly->clone());
     
218. plIndex = minParam;
     
219. ptMinClose = ptClosest;
     
220. 
     
221. 
     
222. }
     
223. else if(st == AcDbPolyline::SegType::kLine)
     
224. {
     
225. AcGeLineSeg3d line3d;
     
226. pPoly->getLineSegAt(minParam,line3d);
     
227. 
     
228. 
     
229. segType = st;
     
230. plMin = AcDbPolyline::cast(pPoly->clone());
     
231. plIndex = minParam;
     
232. ptMinClose = ptClosest;
     
233. 
     
234. 
     
235. }
     
236. pEnt->close();
     
237. }
     
238. 
     
239. 
     
240. //释放资源-------------------------------------------
     
241. //pEnt->close();
     
242. acutRelRb(strFilter);
     
243. acedSSFree(ssName);
     
244. 
     
245. 
     
246. //判断最小距离是否超出了系统允许的最大值
     
247. if(minDist >MINDISTANCE)
     
248. {
     
249. acutPrintf(_T("\n最小距离至少为%.2f"),MINDISTANCE);
     
250. delete plMin;
     
251. return;
     
252. }
     
253. 
     
254. 
     
255. //绘制转角线段-------------------------------------------------
     
256. AcDbPolyline * pLine = new AcDbPolyline();
     
257. 
     
258. ////线段
     
259. if(segType == AcDbPolyline::SegType::kLine)
     
260. {
     
261. AcGeLineSeg2d line2d;
     
262. plMin->getLineSegAt(plIndex,line2d);
     
263. 
     
264. 
     
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);
     
275. 
     
276. 
     
277. pLine->addVertexAt(0,arc2d.startPoint(),bulge);
     
278. pLine->addVertexAt(1,arc2d.endPoint());
     
279. }
     
280. 
     
281. 
     
282. Acad::ErrorStatus es = pLine->setLayer(strLayer);
     
283. if(Acad::eOk != es)
     
284. {
     
285. acutPrintf(_T("\n设置层名称出错"));
     
286. }
     
287. 
     
288. 
     
289. es = pLine->setConstantWidth(lineWeight);
     
290. if(Acad::eOk != es)
     
291. {
     
292. acutPrintf(_T("\n设置曲线宽度出错"));
     
293. }
     
294. 
     
295. 
     
296. AcDbObjectIdArray idArr;
     
297. AcDbObjectId idLine = LoadEntity(pLine);
     
298. idArr.append(idLine);////记录ObjId
     
299. 
     
300. 
     
301. //绘制禁止开口两边-------------------------
     
302. 
     
303. 
     
304. ////第一个邻边
     
305. //--------------箭头-----------------------
     
306. 
     
307. AcGePoint3d pt3dS;
     
308. AcGePoint3d pt3dE;
     
309. AcGePoint2d pt2dS;
     
310. AcGePoint2d pt2dE;
     
311. 
     
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();
     
323. 
     
324. 
     
325. }
     
326. else
     
327. {
     
328. AcGeLineSeg3d line3d;
     
329. plMin->getLineSegAt(plIndex,line3d);
     
330. AcGeLineSeg2d line2d;
     
331. plMin->getLineSegAt(plIndex,line2d);
     
332. 
     
333. 
     
334. pt3dS = line3d.startPoint();
     
335. pt3dE = line3d.endPoint();
     
336. pt2dS = line2d.startPoint();
     
337. pt2dE = line2d.endPoint();
     
338. }
     
339. 
     
340. 
     
341. AcDbObjectId idPointer1;
     
342. DrawPointer(plMin,!gotonext,plIndex,pt3dS,idPointer1);
     
343. 
     
344. 
     
345. ads_real dis=DEFAULT_LEN;
     
346. 
     
347. 
     
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);
     
352. 
     
353. 
     
354. int polyIndex = 0;
     
355. if(ret == RTCAN)
     
356. {
     
357. EraseIds(idArr);
     
358. RemoveEntity(idPointer1);
     
359. delete plMin;
     
360. return;
     
361. }
     
362. 
     
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;
     
373. 
     
374. 
     
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. }
     
384. 
     
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);
     
391. 
     
392. 
     
393. AcGePoint2d ptClose2d;
     
394. Pt3dTo2d(ptMinClose,ptClose2d);
     
395. double curBulge = 0.0;
     
396. plMin->getBulgeAt(plIndex,curBulge);
     
397. 
     
398. 
     
399. ////向前面画
     
400. length = abs(disS - disC);
     
401. 
     
402. AcDbPolyline* pl1 = new AcDbPolyline();
     
403. pl1->setConstantWidth(lineWeight);
     
404. pl1->setLayer(strLayer);
     
405. int pl1Index = 0;
     
406. 
     
407. StartWithP(plMin,plIndex,dis,length,segType,ptClose2d,!gotonext,pl1,pl1Index);
     
408. 
     
409. 
     
410. AcDbObjectId idPl1 = LoadEntity(pl1);
     
411. pIdArr.append(idPl1);
     
412. ////移除第1个箭头
     
413. RemoveEntity(idPointer1);
     
414. 
     
415. 
     
416. ////--------------------向后面画--先画箭头------------------------
     
417. AcDbObjectId idPointer2;
     
418. DrawPointer(plMin,gotonext,plIndex,pt3dE,idPointer2);
     
419. 
     
420. int count = plMin->numVerts();
     
421. 
     
422. 
     
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);
     
436. 
     
437. 
     
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. }
     
448. 
     
449. StartWithP(plMin,plIndex,dis,length,segType,ptClose2d,gotonext,pl2,pl2Index);
     
450. 
     
451. 
     
452. AcDbObjectId idPl2 = LoadEntity(pl2);
     
453. pIdArr.append(idPl2);
     
454. 
     
455. ////移除第二个箭头
     
456. RemoveEntity(idPointer2);
     
457. 
     
458. 
     
459. 
     
460. AcDbPolyline* plAll = new AcDbPolyline();
     
461. plAll->setConstantWidth(lineWeight);
     
462. plAll->setLayer(strLayer);
     
463. 
     
464. int plAllIndex = 0;
     
465. AppendPLinePoint(idPl1,!gotonext,plAll,plAllIndex);
     
466. AppendPLinePoint(idPl2,gotonext,plAll,plAllIndex);
     
467. LoadEntity(plAll);
     
468. 
     
469. 
     
470. EraseIds(pIdArr);
     
471. }
     
472. 
     
473. 
     
474. delete plMin;
     
475. return;
     
476. }
     
477. //不是点击位置开始的情况------------------------------------
     
478. 
     
479. 
     
480. 
     
481. //第一条边
     
482. 
     
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);
     
490. 
     
491. 
     
492. DrawByLen(!gotonext,ptNextE,ptNextS,dis,plMin,pLine1,pLine1Index);
     
493. 
     
494. AcDbObjectId idLine1 = LoadEntity(pLine1);
     
495. idArr.append(idLine1);
     
496. RemoveEntity(idPointer1);
     
497. 
     
498. //第二条边
     
499. 
     
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. }
     
509. 
     
510. 
     
511. AcDbObjectId idPointer2;
     
512. DrawPointer(plMin,gotonext,plIndex,pt3dE,idPointer2);
     
513. 
     
514. 
     
515. AcDbPolyline* pLine2 = new AcDbPolyline();
     
516. pLine2->setConstantWidth(lineWeight);
     
517. pLine2->setLayer(strLayer);
     
518. 
     
519. 
     
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);
     
524. 
     
525. 
     
526. idArr.append(idLine2);
     
527. RemoveEntity(idPointer2);
     
528. delete plMin;
     
529. 
     
530. 
     
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);
     
539. 
     
540. 
     
541. LoadEntity(pl);
     
542. 
     
543. 
     
544. //////移除之前画上去的3条多段线
     
545. EraseIds(idArr);
     
546. 
     
547. }
     
548. 
     
549. 
     
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;
     
558. 
     
559. 
     
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. }
     
575. 
     
576. 
     
577. 
     
578. 
     
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. }
     
586. 
     
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. }
     
601. 
     
602. 
     
603. AcGePoint2d ptNextS;
     
604. AcGePoint2d ptNextE;
     
605. GetNextPt(plMin,gotonext,plIndex,ptNextS,ptNextE);
     
606. 
     
607. 
     
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);
     
630. 
     
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. }
     
640. 
     
641. 
     
642. double bulge1 = 0.0;
     
643. if(segType == AcDbPolyline::SegType::kArc)
     
644. {
     
645. bulge1 = tan(atan(curBulge) * dis / thisLen);
     
646. }
     
647. 
     
648. 
     
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. }
     
660. 
     
661. }
     
662. 
     
663. 
     
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. }
     
690. 
     
691. 
     
692. AcDbPolyline::SegType nextType = plMin->segType(nextIndex);
     
693. 
     
694. 
     
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. }
     
709. 
     
710. 
     
711. }
     
712. 
     
713. 
     
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. }
     
729. 
     
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. }
     
763. 
     
764. pEnt->close();
     
765. }
     
766. 
     
767. 
     
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. }
     
788. 
     
789. 
     
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;
     
798. 
     
799. 
     
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. }
     
813. 
     
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]);
     
823. 
     
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);
     
833. 
     
834. 
     
835. vVer.rotateBy(PI/2);
     
836. AcGePoint2d pt1 = pt0 + vVer *POINTERWIDTH / 2;
     
837. pLine->addVertexAt(1,pt1);
     
838. 
     
839. 
     
840. vVer.rotateBy(-PI/2);
     
841. AcGePoint2d pt2 = pt1 + vVer * POINTERLENGTH;
     
842. pLine->addVertexAt(2,pt2);
     
843. 
     
844. 
     
845. vVer.rotateBy(PI/2);
     
846. AcGePoint2d pt3 = pt2 + vVer * POINTERWIDTH / 2;
     
847. pLine->addVertexAt(3,pt3);
     
848. 
     
849. 
     
850. vVer.rotateBy(- 3 * PI/4);
     
851. AcGePoint2d pt4 = pt3 + vVer * sqrt(2.0) * POINTERWIDTH;
     
852. pLine->addVertexAt(4,pt4);
     
853. 
     
854. 
     
855. vVer.rotateBy(-PI/2);
     
856. AcGePoint2d pt5 = pt4 + vVer * sqrt(2.0) * POINTERWIDTH;
     
857. pLine->addVertexAt(5,pt5);
     
858. 
     
859. 
     
860. vVer.rotateBy(-3 * PI/4);
     
861. AcGePoint2d pt6 = pt5 + vVer * POINTERWIDTH / 2;
     
862. pLine->addVertexAt(6,pt6);
     
863. 
     
864. 
     
865. vVer.rotateBy(PI/2);
     
866. AcGePoint2d pt7 = pt6 + vVer * POINTERLENGTH ;
     
867. pLine->addVertexAt(7,pt7);
     
868. 
     
869. 
     
870. vVer.rotateBy(-PI/2);
     
871. AcGePoint2d pt8 = pt7 + vVer * POINTERWIDTH / 2;
     
872. pLine->addVertexAt(8,pt8);
     
873. idPointer = LoadEntity(pLine);
     
874. }
     
875. 
     
876. 
     
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. }
     
894. 
     
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. }
     
902. 
     
903. 
     
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. }
     
909. 
     
910. 
     
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();
     
922. 
     
923. AcGeCircArc2d arc2d;
     
924. AcGeLineSeg2d line2d;
     
925. 
     
926. 
     
927. AcGePoint2d ptS;
     
928. AcGePoint2d ptE;
     
929. bool isFind = false;
     
930. int plIndex = 0;
     
931. AcGeCurve2d* pCurve = NULL;
     
932. 
     
933. for(int i = 0;i < len;i++)
     
934. {
     
935. AcDbPolyline::SegType st = pl->segType(i);
     
936. 
     
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. }
     
947. 
     
948. 
     
949. if(!pCurve->hasStartPoint(ptS) || !pCurve->hasEndPoint(ptE))
     
950. {
     
951. continue;
     
952. }
     
953. 
     
954. if(ptS == from && ptE == to || ptS == to && ptE == from)
     
955. {
     
956. plIndex = i;
     
957. isFind = true;
     
958. break;
     
959. }
     
960. }
     
961. 
     
962. 
     
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. }
     
973. 
     
974. 
     
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. {
     
987. 
     
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();
     
998. 
     
999. 
     
1000. if(polyIndex == 2*(len - 2))
      
1001. {
      
1002. acutPrintf(_T("\nend poly is %d"),polyIndex);
      
1003. return;
      
1004. }
      
1005. 
      
1006. 
      
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;
      
1023. 
      
1024. 
      
1025. pl->getBulgeAt(plIndex,bulge);
      
1026. 
      
1027. 
      
1028. if(curveDis > leftDis)
      
1029. {
      
1030. double paramEnding = 0.0;
      
1031. 
      
1032. if(gotoNext)
      
1033. {
      
1034. AcGePoint2d ptEnding;
      
1035. AcGePoint2d ptS;
      
1036. pCurve->hasStartPoint(ptS);
      
1037. GetPtAtDistOnCurve(pCurve,ptS,leftDis,ptEnding,Adesk::kTrue);
      
1038. 
      
1039. 
      
1040. bulge = tan(atan(bulge) * leftDis/curveDis);
      
1041. 
      
1042. 
      
1043. pPoly->addVertexAt(polyIndex,ptS,bulge);
      
1044. polyIndex ++;
      
1045. pPoly->addVertexAt(polyIndex,ptEnding);
      
1046. }
      
1047. else
      
1048. {
      
1049. AcGePoint2d ptEnding;
      
1050. 
      
1051. 
      
1052. AcGePoint2d ptE;
      
1053. pCurve->hasEndPoint(ptE);
      
1054. GetPtAtDistOnCurve(pCurve,ptE,leftDis,ptEnding,Adesk::kFalse);
      
1055. 
      
1056. 
      
1057. bulge = tan(atan(bulge) * leftDis/curveDis);
      
1058. 
      
1059. 
      
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 ++;
      
1082. 
      
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;
      
1086. 
      
1087. }
      
1088. 
      
1089. 
      
1090. if(gotoNext)
      
1091. {
      
1092. plIndex = plIndex < len - 1  ? ++plIndex : 0;
      
1093. }
      
1094. else
      
1095. {
      
1096. plIndex = plIndex > 0 ? --plIndex : len - 1;
      
1097. }
      
1098. 
      
1099. 
      
1100. DrawIt(gotoNext,pl,paramDis,ptStart,polyIndex,plIndex,sumDis,pPoly);
      
1101. 
      
1102. 
      
1103. }
      
1104. 
      
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;
      
1119. 
      
1120. datumParam = pCurve->paramOf(ptS);
      
1121. pa = pCurve->paramAtLength(datumParam,dist,isGotoNext);
      
1122. point = pCurve->evalPoint(pa);
      
1123. }
      
1124. 
      

复制代码

sunny20102

你要说明你的autocad版本, 不然别人编译链接后不一定能用

我是初学者,还没有入门,因为C基础差,学起来事倍功半

shuaier

sunny20102 发表于 2012-10-29 15:25
你要说明你的autocad版本, 不然别人编译链接后不一定能用

我是初学者,还没有入门,因为C基础差,学起来事倍 ...

CAD2006就可以了

齐天大圣3386

shuaier 发表于 2012-12-21 09:12
CAD2006就可以了

编译完了，你准备怎么用啊？

shuaier

齐天大圣3386 发表于 2012-12-21 10:43
编译完了，你准备怎么用啊？

直接拖到CAD窗口加载，然后使用命令操作