一个弧长动态尺寸

admin

1. #pragma once
4. class CArcTestJig: public AcEdJig
5. {
6. public:
7.         CArcTestJig();
8.         virtual ~CArcTestJig();
10.         //- dynamic dimension data setup
11.         virtual AcDbDimDataPtrArray* dimData (const double dimScale) override;
12.         //- dynamic dimension data update
13.         virtual Acad::ErrorStatus setDimValue(const AcDbDimData* dimData,        const double dimValue) override;
15.         virtual Adesk::Boolean update() override;
16.         virtual DragStatus sampler() override;
17.         virtual AcDbEntity* entity() const override         { return m采用pArc;  }
19.         AcEdJig::DragStatus start();
21. protected:
22.         void  releaseDimData();
23.         void  updateDimData();
24.         void  setEndAngleTo(AcGePoint3d pntEnd);
26. protected:
28. #define ARCDIM采用OFFSET  20.0
30.         enum stage
31.         {
32.                 center = 1,
33.                 startpnt,
34.                 endpnt
35.         };
37.         stage        m采用Stage;
38.         AcGePoint3d  m采用PntPrev;
39.         AcDbArc*     m采用pArc;
41.         AcDbDimDataPtrArray* m采用pDimData;
43.         double     采用采用PI;
44. };
46. void CreateArc();
50. #include "StdAfx.h"
51. #include "ArcTestJig.h"
53. //
54. CArcTestJig::CArcTestJig(): m采用Stage(center), m采用pDimData(NULL), 采用采用PI(atan (1.)*4)
55. {
56.         m采用pArc = new AcDbArc(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis, 100., 0., 采用采用PI/2);
57. }
59. CArcTestJig::~CArcTestJig()
60. {
61.         releaseDimData();
62. };
64. void CArcTestJig::releaseDimData()
65. {
66.         if(m采用pDimData == NULL)
67.                 return;
68.         for(int ii = 0; ii < m采用pDimData->length(); ii++)
69.                 delete m采用pDimData->at(ii);
71.         delete m采用pDimData;
72.         m采用pDimData = NULL;
73. }
75. void  CArcTestJig::updateDimData()
76. {
77.         if(m采用pDimData == NULL || m采用pArc == NULL)
78.                 return;
80.         if(m采用pDimData->length() < 2)
81.                 return;
83.         double  dRadius = m采用pArc->radius();
84.         AcGePoint3d  pntCenter = m采用pArc->center();
86.         AcGePoint3d  pntStart;
87.         m采用pArc->getStartPoint(pntStart);
88.         double dStart;
89.         m采用pArc->getStartParam(dStart);
91.         AcGePoint3d  pntEnd;
92.         m采用pArc->getEndPoint(pntEnd);
93.         double dEnd;
94.         m采用pArc->getEndParam(dEnd);
96.         AcDbArcDimension* pArcDim = AcDbArcDimension::cast(m采用pDimData->at(0)->dimension());
97.         if(pArcDim)
98.         {
99.                 pArcDim->setArcSymbolType(2); // no symbol
100.                 pArcDim->setCenterPoint(pntCenter);
101.                 pArcDim->setXLine1Point(pntStart);
102.                 pArcDim->setXLine2Point(pntEnd);
103.                 pArcDim->setArcStartParam(dStart);
104.                 pArcDim->setArcEndParam(dEnd);
106.                 AcGeVector3d vStart = (pntStart - pntCenter).normalize();
107.                 AcGeVector3d vEnd = (pntEnd - pntCenter).normalize();
108.                 AcGeVector3d vMid = vStart + vEnd;
109.                 vMid.normalize();
111.                 if(vStart.angleTo(vEnd, m采用pArc->normal()) > 采用采用PI)
112.                         vMid.negate();
114.                 pArcDim->setArcPoint(pntCenter + (dRadius + ARCDIM采用OFFSET)*vMid );
116.                 pArcDim->setHasLeader(false);
117.         }
119.         AcDbAlignedDimension* pChordDim = AcDbAlignedDimension::cast(m采用pDimData->at(1)->dimension());
120.         if(pChordDim)
121.         {
122.                 pChordDim->setXLine1Point(pntStart);
123.                 pChordDim->setXLine2Point(pntEnd);
124.                 AcGeVector3d vDir = (pntEnd - pntStart).normalize();
126.                 pChordDim->setDimLinePoint(pntStart + ARCDIM采用OFFSET*vDir.perpVector());
127.         }
128. }
130. AcDbDimDataPtrArray* CArcTestJig::dimData (const double dimScale)
131. {
132.         if(m采用Stage != endpnt)
133.                 return NULL;
135.         releaseDimData();
137.         m采用pDimData = new AcDbDimDataPtrArray();
139.         AcDbDimData* pNewData(NULL);
141.         // Arc Dimension
142.         AcDbArcDimension* pArcDim = new AcDbArcDimension();
143.         pArcDim->setDatabaseDefaults();
144.         pArcDim->setNormal(m采用pArc->normal());
145.         pArcDim->setElevation(0.0);
146.         pArcDim->setHorizontalRotation(0.0);
147.         pArcDim->setDimscale(dimScale);
148.         pArcDim->setDimtad(1);
149. //        pArcDim->setDynamicDimension(true);
151.         pNewData = new AcDbDimData(pArcDim);
152.         pNewData->setDimHideIfValueIsZero(false);
153.         pNewData->setDimEditable(true);
154.         pNewData->setDimFocal(true);
156.         m采用pDimData->append(pNewData);
158.         // Chord Dimension
159.         AcDbAlignedDimension* pChordDim = new AcDbAlignedDimension();
160.         pChordDim->setDatabaseDefaults();
161.         pChordDim->setNormal(m采用pArc->normal());
162.         pChordDim->setElevation(0.0);
163.         pChordDim->setHorizontalRotation(0.0);
164.         pChordDim->setDimtad(1);
165.         pChordDim->setDynamicDimension(true);
167.         pNewData = new AcDbDimData(pChordDim);
168.         pNewData->setDimHideIfValueIsZero(false);
169.         pNewData->setDimEditable(true);
170.         pNewData->setDimFocal(false);
172.         m采用pDimData->append(pNewData);
174.         // set dimension location
175.         updateDimData();
177.         return m采用pDimData;
178. }
180. Acad::ErrorStatus CArcTestJig::setDimValue(const AcDbDimData* dimData,        const double dimValue)
181. {
182.         AcDbDimension* pDim = dimData->dimension();
184.         AcDbArcDimension* pArcDim = AcDbArcDimension::cast(pDim);
185.         if(pArcDim)
186.         {
187.                 AcGePoint3d pntNewEnd;
188.                 Acad::ErrorStatus es = m采用pArc->getPointAtDist(dimValue, pntNewEnd);
189.                 if(Acad::eOk != es)
190.                         return es;
192.                 setEndAngleTo(pntNewEnd);
194.                 return Acad::eOk;
195.         }
196.         else
197.         {
198.                 AcDbAlignedDimension* pChordDim =  AcDbAlignedDimension::cast(pDim);
199.                 if(pChordDim)
200.                 {
201.                         double dRadius = m采用pArc->radius();
202.                         if(dimValue > dRadius*2)
203.                                 return Acad::eNotApplicable;
206.                         double dAngDlt = asin(dimValue/(dRadius*2));
207.                         double dNewEnd = m采用pArc->startAngle() + dAngDlt*2;
208.                         m采用pArc->setEndAngle(dNewEnd);
209.                         return Acad::eOk;
210.                 }
211.         }
213.         return  Acad::eInvalidInput;
214. }
216. void  CArcTestJig::setEndAngleTo(AcGePoint3d pntEnd)
217. {
218.         AcGeVector3d vEnd = (pntEnd - m采用pArc->center()).normalize();
219.         double dNewEnd = vEnd.angleTo(AcGeVector3d::kXAxis, m采用pArc->normal().negate());
220. //         if(dNewEnd > 采用采用PI)
221. //                 dNewEnd -= 采用采用PI*2;
222.         m采用pArc->setEndAngle(dNewEnd);
223. }
225. Adesk::Boolean CArcTestJig::update()
226. {
227.         if(m采用pArc == NULL)
228.                 return false;
230.         switch(m采用Stage)
231.         {
232.                 case center:
233.                         m采用pArc->setCenter(m采用PntPrev);
234.                         break;
236.                 case startpnt:
237.                         {
238.                                 AcGeVector3d vStart = m采用PntPrev - m采用pArc->center();
239.                                 double dRadius = vStart.length();
240.                                 vStart.normalize();
241.                                 double dStart = vStart.angleTo(AcGeVector3d::kXAxis, m采用pArc->normal().negate());
242.                                 if(dStart > 采用采用PI)
243.                                         dStart -= 采用采用PI*2;
244.                                 m采用pArc->setRadius(dRadius);
245.                                 m采用pArc->setStartAngle(dStart);
246.                                 m采用pArc->setEndAngle(dStart + 采用采用PI/2);
247.                         }
248.                         break;
250.                 case endpnt:
251.                         setEndAngleTo(m采用PntPrev);
252.                         break;
254.                 default:
255.                         return false;
256.         }
258.         updateDimData();
259.         return true;
260. }
262. AcEdJig::DragStatus CArcTestJig::sampler()
263. {
264.         setUserInputControls((UserInputControls)        (        AcEdJig::kAccept3dCoordinates        | AcEdJig::kNullResponseAccepted));
266.         DragStatus sts;
267.         AcGePoint3d pntTemp;
268.         if(m采用Stage == startpnt)
269.                 sts = acquirePoint(pntTemp, m采用pArc->center());
270.         else
271.                 sts = acquirePoint(pntTemp);
272.         if(sts == AcEdJig::kNormal)
273.         {
274.                 if(pntTemp.isEqualTo(m采用PntPrev))
275.                         sts = kNoChange;
276.                 m采用PntPrev = pntTemp;
277.         }
278.         return sts;
279. }
281. AcEdJig::DragStatus  CArcTestJig::start()
282. {
283.         CString sPrompt;
285.         m采用Stage = center;
286.         sPrompt = 采用T("\nCenter of arc: ");
287.         setDispPrompt(sPrompt);
288.         AcEdJig::DragStatus sts = drag();
289.         if(sts != kNormal)
290.                 return sts;
292.         m采用Stage = startpnt;
293.         sPrompt = 采用T("\nStart point of arc: ");
294.         setDispPrompt(sPrompt);
295.         m采用pArc->getStartPoint(m采用PntPrev);
296.         sts = drag();
297.         if(sts != kNormal)
298.                 return sts;
300.         m采用Stage = endpnt;
301.         sPrompt = 采用T("\nEnd point of arc: ");
302.         setDispPrompt(sPrompt);
303.         m采用pArc->getEndPoint(m采用PntPrev);
304.         sts = drag();
305.         if(sts == kNormal)
306.         {
307.                 AcDbObjectId idArc = append();
308.         }
310.         return sts;
311. }
313. void CreateArc()
314. {
315.         CArcTestJig arcJig;
316.         arcJig.start();
317. }

复制代码