设为首页收藏本站CAD论坛CAD教程CAD下载明经币充值
切换到宽版

明经CAD社区

 找回密码
 注册

QQ登录

只需一步，快速开始

搜索
明经CAD社区»社区 › 开发篇 › ObjectARX/VC++ 编程技术 › 哪位大侠帮我弄成CAD可执行的程序，谢谢！
返回列表 发新帖
查看: 2681|回复: 4

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

[复制链接]
shuaier
发表于 2012-9-27 11:21:19 | 显示全部楼层 |阅读模式
本帖最后由 shuaier 于 2012-9-27 11:48 编辑

编好后发到我的邮箱414528096@qq.com，非常感谢！
  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. }

复制代码
回复

使用道具 举报

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

我是初学者,还没有入门,因为C基础差,学起来事倍功半
回复 支持 反对

使用道具 举报

shuaier
 楼主| 发表于 2012-12-21 09:12:42 | 显示全部楼层
sunny20102 发表于 2012-10-29 15:25
你要说明你的autocad版本, 不然别人编译链接后不一定能用

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

CAD2006就可以了
回复 支持 反对

使用道具 举报

齐天大圣3386
发表于 2012-12-21 10:43:27 | 显示全部楼层
shuaier 发表于 2012-12-21 09:12
CAD2006就可以了

编译完了，你准备怎么用啊？
回复 支持 反对

使用道具 举报

shuaier
 楼主| 发表于 2012-12-26 12:55:32 | 显示全部楼层
齐天大圣3386 发表于 2012-12-21 10:43
编译完了，你准备怎么用啊？

直接拖到CAD窗口加载，然后使用命令操作
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

小黑屋|手机版|CAD论坛|CAD教程|CAD下载|联系我们|关于明经|明经通道 ( 粤ICP备05003914号 )  
©2000-2023 明经通道 版权所有 本站代码，在未取得本站及作者授权的情况下，不得用于商业用途

GMT+8, 2024-11-25 07:56 , Processed in 0.176827 second(s), 23 queries , Gzip On.

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表