Offset Polyline

theswamp

• 1. using System;

     1. using System.Collections.Generic;

     2. using System.Linq;

     3. using Autodesk.AutoCAD.DatabaseServices;

     5. namespace OffsetPolylineSample

     6. {

     7. /// <summary>

     8. /// Provides the Offset() extension method for the Polyline type

     9. /// </summary>

     10. public static class PolylineExtension

     11. {

     12. /// <summary>

     13. /// Enumeration of offset side options

     14. /// </summary>

     15. public enum OffsetSide { In, Out, Left, Right, Both }

     17. /// <summary>

     18. /// Offset the source polyline to specified side(s).

     19. /// </summary>

     20. /// <param name="source">The polyline to be offseted.</param>

     21. /// <param name="offsetDist">The offset distance.</param>

     22. /// <param name="side">The offset side(s).</param>

     23. /// <returns>A polyline sequence resulting from the offset of the source polyline.</returns>

     24. public static IEnumerable<Polyline> Offset(this Polyline source, double offsetDist, OffsetSide side)

     25. {

     26. offsetDist = Math.Abs(offsetDist);

     27. IEnumerable<Polyline> offsetRight = source.GetOffsetCurves(offsetDist).Cast<Polyline>();

     28. double areaRight = offsetRight.Select(pline => pline.Area).Sum();

     29. IEnumerable<Polyline> offsetLeft = source.GetOffsetCurves(-offsetDist).Cast<Polyline>();

     30. double areaLeft = offsetLeft.Select(pline => pline.Area).Sum();

     31. switch (side)

     32. {

     33. case OffsetSide.In:

     34. if (areaRight < areaLeft)

     35. {

     36. offsetLeft.Dispose();

     37. return offsetRight;

     38. }

     39. else

     40. {

     41. offsetRight.Dispose();

     42. return offsetLeft;

     43. }

     44. case OffsetSide.Out:

     45. if (areaRight < areaLeft)

     46. {

     47. offsetRight.Dispose();

     48. return offsetLeft;

     49. }

     50. else

     51. {

     52. offsetLeft.Dispose();

     53. return offsetRight;

     54. }

     55. case OffsetSide.Left:

     56. offsetRight.Dispose();

     57. return offsetLeft;

     58. case OffsetSide.Right:

     59. offsetLeft.Dispose();

     60. return offsetRight;

     61. case OffsetSide.Both:

     62. return offsetRight.Concat(offsetLeft);

     63. default:

     64. return null;

     65. }

     66. }

     68. private static void Dispose(this IEnumerable<Polyline> plines)

     69. {

     70. foreach (Polyline pline in plines)

     71. {

     72. pline.Dispose();

     73. }

     74. }

     75. }

     76. }

     77. using Autodesk.AutoCAD.ApplicationServices;

     78. using Autodesk.AutoCAD.DatabaseServices;

     79. using Autodesk.AutoCAD.EditorInput;

     80. using Autodesk.AutoCAD.Runtime;

     82. namespace OffsetPolylineSample

     83. {

     84. public class CommandMethods

     85. {

     86. [CommandMethod("Test", CommandFlags.Modal)]

     87. public void Test()

     88. {

     89. Document doc = Application.DocumentManager.MdiActiveDocument;

     90. Database db = doc.Database;

     91. Editor ed = doc.Editor;

     93. PromptDistanceOptions pdo =

     94. new PromptDistanceOptions("\nSpecify the offset distance: ");

     95. pdo.AllowZero = false;

     96. PromptDoubleResult pdr = ed.GetDistance(pdo);

     97. if (pdr.Status != PromptStatus.OK) return;

     98. double offsetDist = pdr.Value;

     100. PromptKeywordOptions pko =

     101. new PromptKeywordOptions("\nEnter the offset side [In/Out/Left/Right/Both]", "In Out Left Right Both");

     102. PromptResult pr = ed.GetKeywords(pko);

     103. if (pr.Status != PromptStatus.OK) return;

     104. PolylineExtension.OffsetSide side;

     105. switch (pr.StringResult)

     106. {

     107. case "In": side = PolylineExtension.OffsetSide.In; break;

     108. case "Out": side = PolylineExtension.OffsetSide.Out; break;

     109. case "Left": side = PolylineExtension.OffsetSide.Left; break;

     110. case "Right": side = PolylineExtension.OffsetSide.Right; break;

     111. default: side = PolylineExtension.OffsetSide.Both; break;

     112. }

     114. PromptEntityOptions peo = new PromptEntityOptions("\nSelect a polyline: ");

     115. peo.SetRejectMessage("Only a polyline !");

     116. peo.AddAllowedClass(typeof(Polyline), true);

     118. using (Transaction tr = db.TransactionManager.StartTransaction())

     119. {

     120. BlockTableRecord btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);

     121. while (true)

     122. {

     123. PromptEntityResult per = ed.GetEntity(peo);

     124. if (per.Status != PromptStatus.OK) break;

     126. Polyline pline = (Polyline)tr.GetObject(per.ObjectId, OpenMode.ForRead);

     127. foreach (Polyline pl in pline.Offset(offsetDist, side))

     128. {

     129. btr.AppendEntity(pl);

     130. tr.AddNewlyCreatedDBObject(pl, true);

     131. }

     132. db.TransactionManager.QueueForGraphicsFlush();

     133. }

     134. tr.Commit();

     135. }

     136. }

     137. }

     138. }

     139. using System;

     140. using System.Collections.Generic;

     141. using System.Linq;

     142. using Autodesk.AutoCAD.DatabaseServices;

     144. namespace OffsetPolylineSample

     145. {

     146. /// <summary>

     147. /// Provides the Offset() extension method for the Polyline type

     148. /// </summary>

     150. public static class PolylineExtension

     151. {

     152. /// <summary>

     153. /// Enumeration of offset side options

     154. /// </summary>

     155. public enum OffsetSide

     156. {

     157. In, Out, Left, Right, Both

     158. }

     160. /// <summary>

     161. /// Offset the source polyline to specified side(s).

     162. /// </summary>

     163. /// <param name="source">The polyline to be offseted.</param>

     164. /// <param name="offsetDist">The offset distance.</param>

     165. /// <param name="side">The offset side(s).</param>

     166. /// <returns>A polyline sequence resulting from the offset of the source polyline.</returns>

     167. public static IEnumerable<Polyline> Offset( this Polyline source, double offsetDist, OffsetSide side )

     168. {

     169. offsetDist = Math.Abs( offsetDist );

     170. using( var plines = new DisposableSet<Polyline>() )

     171. {

     172. IEnumerable<Polyline> offsetRight = source.GetOffsetCurves( offsetDist ).Cast<Polyline>();

     173. plines.AddRange( offsetRight );

     174. IEnumerable<Polyline> offsetLeft = source.GetOffsetCurves( -offsetDist ).Cast<Polyline>();

     175. plines.AddRange( offsetLeft );

     176. double areaRight = offsetRight.Select( pline => pline.Area ).Sum();

     177. double areaLeft = offsetLeft.Select( pline => pline.Area ).Sum();

     178. switch( side )

     179. {

     180. case OffsetSide.In:

     181. if( areaRight < areaLeft )

     182. {

     183. plines.RemoveRange( offsetRight );

     184. return offsetRight;

     185. }

     186. else

     187. {

     188. plines.RemoveRange( offsetLeft );

     189. return offsetLeft;

     190. }

     191. case OffsetSide.Out:

     192. if( areaRight < areaLeft )

     193. {

     194. plines.RemoveRange( offsetLeft );

     195. return offsetLeft;

     196. }

     197. else

     198. {

     199. plines.RemoveRange( offsetRight );

     200. return offsetRight;

     201. }

     202. case OffsetSide.Left:

     203. plines.RemoveRange( offsetLeft );

     204. return offsetLeft;

     205. case OffsetSide.Right:

     206. plines.RemoveRange( offsetRight );

     207. return offsetRight;

     208. case OffsetSide.Both:

     209. plines.Clear();

     210. return offsetRight.Concat( offsetLeft );

     211. default:

     212. return null;

     213. }

     214. }

     215. }

     216. }

     218. public class DisposableSet<T> : HashSet<T>, IDisposable where T: IDisposable

     219. {

     220. public void Dispose()

     221. {

     222. System.Exception last = null;

     223. foreach( T item in this )

     224. {

     225. if( item != null )

     226. {

     227. try

     228. {

     229. item.Dispose();

     230. }

     231. catch( System.Exception ex )

     232. {

     233. last = last ?? ex;

     234. }

     235. }

     236. }

     237. this.Clear();

     238. if( last != null )

     239. throw last;

     240. }

     242. public void AddRange( IEnumerable<T> items )

     243. {

     244. foreach( T item in items )

     245. {

     246. if( item == null )

     247. throw new ArgumentNullException( "element" );

     248. base.Add( item );

     249. }

     250. }

     252. public void RemoveRange( IEnumerable<T> items )

     253. {

     254. foreach( T item in items )

     255. {

     256. if( item != null )

     257. base.Remove( item );

     258. }

     259. }

     260. }

     262. }

     263. using System;

     264. using System.Collections.Generic;

     265. using System.Linq;

     266. using Autodesk.AutoCAD.DatabaseServices;

     268. namespace OffsetPolylineSample

     269. {

     270. /// <summary>

     271. /// Provides the Offset() extension method for the Polyline type

     272. /// </summary>

     273. public static class PolylineExtension

     274. {

     275. /// <summary>

     276. /// Enumeration of offset side options

     277. /// </summary>

     278. public enum OffsetSide

     279. {

     280. In, Out, Left, Right, Both

     281. }

     283. /// <summary>

     284. /// Offset the source polyline to specified side(s).

     285. /// </summary>

     286. /// <param name="source">The polyline to be offseted.</param>

     287. /// <param name="offsetDist">The offset distance.</param>

     288. /// <param name="side">The offset side(s).</param>

     289. /// <returns>A polyline sequence resulting from the offset of the source polyline.</returns>

     290. public static IEnumerable<Polyline> Offset( this Polyline source, double offsetDist, OffsetSide side )

     291. {

     292. offsetDist = Math.Abs( offsetDist );

     293. using( var plines = new DisposableSet<Polyline>() )

     294. {

     295. IEnumerable<Polyline> offsetRight = source.GetOffsetCurves( offsetDist ).Cast<Polyline>();

     296. plines.AddRange( offsetRight );

     297. IEnumerable<Polyline> offsetLeft = source.GetOffsetCurves( -offsetDist ).Cast<Polyline>();

     298. plines.AddRange( offsetLeft );

     299. double areaRight = offsetRight.Select( pline => pline.Area ).Sum();

     300. double areaLeft = offsetLeft.Select( pline => pline.Area ).Sum();

     301. switch( side )

     302. {

     303. case OffsetSide.In:

     304. return plines.RemoveRange(

     305. areaRight < areaLeft ? offsetRight : offsetLeft );

     306. case OffsetSide.Out:

     307. return plines.RemoveRange(

     308. areaRight < areaLeft ? offsetLeft : offsetRight );

     309. case OffsetSide.Left:

     310. return plines.RemoveRange( offsetLeft );

     311. case OffsetSide.Right:

     312. return plines.RemoveRange( offsetRight );

     313. case OffsetSide.Both:

     314. plines.Clear();

     315. return offsetRight.Concat( offsetLeft );

     316. default:

     317. return null;

     318. }

     319. }

     320. }

     321. }

     323. public interface IDisposableCollection<T> : ICollection<T>, IDisposable

     324. where T : IDisposable

     325. {

     326. void AddRange( IEnumerable<T> items );

     327. IEnumerable<T> RemoveRange( IEnumerable<T> items );

     328. }

     330. public class DisposableSet<T> : HashSet<T>, IDisposableCollection<T>

     331. where T: IDisposable

     332. {

     333. public DisposableSet()

     334. {

     335. }

     337. public DisposableSet( IEnumerable<T> items )

     338. {

     339. AddRange( items );

     340. }

     342. public void Dispose()

     343. {

     344. if( base.Count > 0 )

     345. {

     346. System.Exception last = null;

     347. var list = this.ToList();

     348. this.Clear();

     349. foreach( T item in list )

     350. {

     351. if( item != null )

     352. {

     353. try

     354. {

     355. item.Dispose();

     356. }

     357. catch( System.Exception ex )

     358. {

     359. last = last ?? ex;

     360. }

     361. }

     362. }

     363. if( last != null )

     364. throw last;

     365. }

     366. }

     368. public void AddRange( IEnumerable<T> items )

     369. {

     370. if( items == null )

     371. throw new ArgumentNullException( "items" );

     372. base.UnionWith( items );

     373. }

     375. public IEnumerable<T> RemoveRange( IEnumerable<T> items )

     376. {

     377. if( items == null )

     378. throw new ArgumentNullException( "items" );

     379. base.ExceptWith( items );

     380. return items;

     381. }

     382. }

     384. }