/Graphics/TreapOfSegments.cs

https://bitbucket.org/kriskk/graphics · C# · 296 lines · 255 code · 19 blank · 22 comment · 60 complexity · 7df9d6b694a1b81ea93b59ca0c484d66 MD5 · raw file 

    

  1. using System;

    2. 

  2. using System.Collections.Generic;

    3. 

  3. using System.Linq;

    4. 

  4. using NUnit.Framework;

    5. 

  5. 

    6. 

  6. namespace PolygonIntersections

    7. 

  7. {

    8. 

  8. 	public static class TreapOfSegments

    9. 

  9. 	{

    10. 

  10. 		#region OrderedInfoMethods // this methods Contract that tree is orderd like binary

    11. 

  11. 		public static Segment Max(this ImplicitTreap<Segment> treap)

    12. 

  12. 		{

    13. 

  13. 			if (treap == null) return null;

    14. 

  14. 			return treap.DigRight().Info;

    15. 

  15. 		}

    16. 

  16. 		public static Segment Min(this ImplicitTreap<Segment> treap)

    17. 

  17. 		{

    18. 

  18. 			if (treap == null) return null;

    19. 

  19. 			return treap.DigLeft().Info;

    20. 

  20. 		}

    21. 

  21. 		

    22. 

  22. 		public static ImplicitTreap<Segment> FindW(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    23. 

  23. 		{

    24. 

  24. 			var compared = comp.Compare(treap.Info, item);

    25. 

  25. 			if (compared < 0)

    26. 

  26. 			{

    27. 

  27. 				if (treap.Right == null) return null;

    28. 

  28. 				return treap.Right.FindW(item, comp);

    29. 

  29. 			}

    30. 

  30. 			if (compared > 0)

    31. 

  31. 			{

    32. 

  32. 				if (treap.Left == null) return null;

    33. 

  33. 				return treap.Left.FindW(item, comp);

    34. 

  34. 			}

    35. 

  35. 			// (compared == 0)

    36. 

  36. 			if (Equals(treap.Info, item)) return treap;

    37. 

  37. 			ImplicitTreap<Segment> check = null;

    38. 

  38. 			if (treap.Left != null)

    39. 

  39. 			{

    40. 

  40. 				check = treap.Left.FindW(item, comp);

    41. 

  41. 				if (check != null) return check;

    42. 

  42. 			}

    43. 

  43. 			if (treap.Right != null)

    44. 

  44. 			{

    45. 

  45. 				check = treap.Right.FindW(item, comp);

    46. 

  46. 				if (check != null) return check;

    47. 

  47. 			}

    48. 

  48. 			return null;

    49. 

  49. 		}

    50. 

  50. 

    51. 

  51. 		public static int? Find(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    52. 

  52. 		{

    53. 

  53. 			if (treap == null) return null;

    54. 

  54. 			var compared = comp.Compare(treap.Info, item);

    55. 

  55. 			if (compared < 0)

    56. 

  56. 			{

    57. 

  57. 				return treap.Right.Find(item, comp) + treap.RightPos;

    58. 

  58. 			}

    59. 

  59. 			if (compared > 0)

    60. 

  60. 			{

    61. 

  61. 				return treap.Left.Find(item, comp);

    62. 

  62. 			}

    63. 

  63. 			// (compared == 0)

    64. 

  64. 			if (Equals(treap.Info, item)) return treap.CurrentPos;

    65. 

  65. 			int? check = null;

    66. 

  66. 			return treap.Left.Find(item, comp) ?? treap.Right.Find(item, comp) + treap.RightPos;

    67. 

  67. 		}

    68. 

  68. 		public static int FindNotNull(this ImplicitTreap<Segment> treap, Segment item, SegmentComparerNotNull comp)

    69. 

  69. 		{

    70. 

  70. 			if (treap == null) return 0;

    71. 

  71. 			var compared = comp.Compare(treap.Info, item);

    72. 

  72. 			if (compared < 0)

    73. 

  73. 			{

    74. 

  74. 				return treap.Right.FindNotNull(item, comp) + treap.RightPos;

    75. 

  75. 			}

    76. 

  76. 			if (compared > 0)

    77. 

  77. 			{

    78. 

  78. 				return treap.Left.FindNotNull(item, comp);

    79. 

  79. 			}

    80. 

  80. 			// (compared == 0)

    81. 

  81. 			if (Equals(treap.Info, item)) return treap.CurrentPos;

    82. 

  82. 			int? check = null;

    83. 

  83. 			if (treap.Left != null && comp.Compare(treap.Left.Max(), item) == 0)

    84. 

  84. 				return treap.Left.FindNotNull(item, comp);

    85. 

  85. 			return treap.Right.FindNotNull(item, comp) + treap.RightPos;

    86. 

  86. 		}

    87. 

  87. 

    88. 

  88. //		public static int? Find(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    89. 

  89. //		{

    90. 

  90. //			int i = 0;

    91. 

  91. //			foreach (var segment in treap.GetAllInfos())

    92. 

  92. //			{

    93. 

  93. //				if (segment.Equals( item)) return i;

    94. 

  94. //				i++;

    95. 

  95. //			}

    96. 

  96. //			return null;

    97. 

  97. //		}

    98. 

  98. 		public static int? FindSimilar(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    99. 

  99. 		{

    100. 

  100. 			var compared = comp.Compare(treap.Info, item);

    101. 

  101. 			if (compared < 0)

    102. 

  102. 			{

    103. 

  103. 				if (treap.Right == null) return null;

    104. 

  104. 				return treap.Right.FindSimilar(item, comp) + treap.RightPos;

    105. 

  105. 			}

    106. 

  106. 			if (compared > 0)

    107. 

  107. 			{

    108. 

  108. 				if (treap.Left == null) return null;

    109. 

  109. 				return treap.Left.FindSimilar(item, comp);

    110. 

  110. 			}

    111. 

  111. 			// (compared == 0)

    112. 

  112. 			return treap.CurrentPos;

    113. 

  113. 		}

    114. 

  114. 

    115. 

  115. 		/// <summary>

    116. 

  116. 		/// Info that is above equivalent to item infos 

    117. 

  117. 		/// </summary>

    118. 

  118. 		public static int? GetCeilPos(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    119. 

  119. 		{

    120. 

  120. 			var fCeil = GetCeilPosQ(treap, item, comp);

    121. 

  121. 			return fCeil >= treap.Size ? null : fCeil;

    122. 

  122. 		}

    123. 

  123. 		private static int? GetCeilPosQ(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    124. 

  124. 		{

    125. 

  125. 			if (treap == null) return null;

    126. 

  126. 			var compared = comp.Compare(treap.Info, item);

    127. 

  127. 			if (compared < 0) // go to Right

    128. 

  128. 			{

    129. 

  129. 				return treap.Right.GetCeilPosQ(item, comp) + treap.RightPos;

    130. 

  130. 			}

    131. 

  131. 			if (compared > 0) // go to Left

    132. 

  132. 			{

    133. 

  133. 				return treap.Left.GetCeilPosQ(item, comp);

    134. 

  134. 			}

    135. 

  135. 			//			 (compared == 0)

    136. 

  136. 			return (treap.Right.GetCeilPosQ(item, comp) ?? 0) + treap.RightPos;

    137. 

  137. 		}

    138. 

  138. 		/// <summary>

    139. 

  139. 		/// Least Info that is equivalent to item

    140. 

  140. 		/// </summary>

    141. 

  141. 		private static int? GetFloorP(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    142. 

  142. 		{

    143. 

  143. 			if (treap == null) return 0;

    144. 

  144. 			var compared = comp.Compare(treap.Info, item);

    145. 

  145. 			if (compared < 0) // go to Right

    146. 

  146. 			{

    147. 

  147. 				return treap.Right.GetFloorP(item, comp) + treap.RightPos;

    148. 

  148. 			}

    149. 

  149. 			if (compared > 0) // go to Left

    150. 

  150. 			{

    151. 

  151. 				return treap.Left.GetFloorP(item, comp);

    152. 

  152. 			}

    153. 

  153. //			 (compared == 0)

    154. 

  154. 			if (treap.Left != null && comp.Compare(treap.Left.Max(), item) == 0)

    155. 

  155. 				return treap.Left.GetFloorP(item, comp);

    156. 

  156. 			return treap.CurrentPos;

    157. 

  157. 		}

    158. 

  158. 

    159. 

  159. 		public static int GetFloorPos(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    160. 

  160. 		{

    161. 

  161. 			return treap.GetFloorP(item, comp) ?? 0;

    162. 

  162. 		}

    163. 

  163. 

    164. 

  164. 		public static ImplicitTreap<Segment> Remove(this ImplicitTreap<Segment> treap, Segment item, SegmentComparer comp)

    165. 

  165. 		{

    166. 

  166. 			var pos = treap.Find(item, comp);

    167. 

  167. 			if (!pos.HasValue) return treap;

    168. 

  168. 			return treap.Remove(pos.Value);

    169. 

  169. 

    170. 

  170. 		}

    171. 

  171. 		public static ImplicitTreap<Segment> Swap(this ImplicitTreap<Segment> treap, Segment s1, Segment s2, SegmentComparer comp)

    172. 

  172. 		{

    173. 

  173. 			var t1 = treap.FindW(s1, comp);

    174. 

  174. 			var t2 = treap.FindW(s2, comp);

    175. 

  175. 			if (t1 == null) return treap;

    176. 

  176. 			if (t2 == null) return treap;

    177. 

  177. 			var temp1 = new Segment(t1.Info);

    178. 

  178. 			var temp2 = new Segment(t2.Info);

    179. 

  179. 			t2.Info = temp1;

    180. 

  180. 			t2.Info = temp1;

    181. 

  181. 			t1.Info = temp2;

    182. 

  182. 			return treap;

    183. 

  183. 

    184. 

  184. 		}

    185. 

  185. 

    186. 

  186. 		public static ImplicitTreap<Segment> CreateOrderedTreapFromRange(Segment[] segments, SegmentComparer comp)

    187. 

  187. 		{

    188. 

  188. 			var t = new ImplicitTreap<Segment>(segments[0]);

    189. 

  189. 			var ans = t;

    190. 

  190. 			foreach (Segment segment in segments.Skip(1))

    191. 

  191. 			{

    192. 

  192. 				var qt = TreapOfSegmentsTester.GetAllI(ans);

    193. 

  193. 				var pos = ans.GetFloorPos(segment, comp);

    194. 

  194. 				ans = ans.Add(pos, segment);

    195. 

  195. 				ans.Recalc();

    196. 

  196. 				qt = TreapOfSegmentsTester.GetAllI(ans);

    197. 

  197. 			}

    198. 

  198. 			ans.Recalc();

    199. 

  199. 			return ans;

    200. 

  200. 		}

    201. 

  201. 

    202. 

  202. 		#endregion

    203. 

  203. 

    204. 

  204. 	}

    205. 

  205. 

    206. 

  206. 	[TestFixture]

    207. 

  207. 	internal class TreapOfSegmentsTester

    208. 

  208. 	{

    209. 

  209. 		public static Segment[] SegsNear = new Segment[]

    210. 

  210. 		                           	{

    211. 

  211. 		                           		new Segment(0,0,6,6), 

    212. 

  212. 		                           		new Segment(0,1,6,1),  

    213. 

  213. 		                           		new Segment(0,2,6,4), 

    214. 

  214. 		                           		new Segment(0,3,6,3), 

    215. 

  215. 		                           		new Segment(0,4,6,2), 

    216. 

  216. 		                           		new Segment(0,5,6,5),

    217. 

  217. 		                           		new Segment(0,6,6,0), 

    218. 

  218. 		                           	};

    219. 

  219. 

    220. 

  220. 		public static Dictionary<Segment, int> Mapper = SegsNear.ToDictionary(q => q, q => (int)q.Start.Y);

    221. 

  221. 		public SegmentComparer Comparer = new SegmentComparer();

    222. 

  222. 

    223. 

  223. 		public static object[][] NearsOrder =

    224. 

  224. 			{

    225. 

  225. 				new object[]

    226. 

  226. 					{

    227. 

  227. 						0.5,

    228. 

  228. 						new     []{0,1,2,3,4,5,6},

    229. 

  229. 						new     []{0,1,2,3,4,5,6},

    230. 

  230. 						new int?[]{1,2,3,4,5,6,null}

    231. 

  231. 					}, 

    232. 

  232. 				new object[]

    233. 

  233. 					{

    234. 

  234. 						2,

    235. 

  235. 						new[]{1,0,2,3,4,6,5},

    236. 

  236. 						new[]{0,1,2,3,4,5,6},

    237. 

  237. 						new int?[]{2,0,3,4,6,null,5}

    238. 

  238. 					}, 

    239. 

  239. 				new object[]

    240. 

  240. 					{

    241. 

  241. 						1,

    242. 

  242. 						new[]{1,0,2,3,4,6,5},

    243. 

  243. 						new[]{1,1,2,3,4,6,6},

    244. 

  244. 						new int?[]{2,2,3,4,6,null, null}

    245. 

  245. 					}, 

    246. 

  246. 				new object[] // awfull and not working // praying for it not to be in algorithm

    247. 

  247. 					{

    248. 

  248. 						3,

    249. 

  249. 						new[]{1,6,4,3,2,0,5},

    250. 

  250. 						new[]{0,1,0,0,0,5,0},

    251. 

  251. 						new int?[]{5,0,5,5,5,null,5}

    252. 

  252. 					}, 

    253. 

  253. 			};

    254. 

  254. 

    255. 

  255. 		[Test]

    256. 

  256. 		[TestCaseSource("NearsOrder")]

    257. 

  257. 		public void NearsTest(double x, int[] finds, int[] floors, int?[] ceils)

    258. 

  258. 		{

    259. 

  259. 			Comparer.X = x;

    260. 

  260. 			var t = TreapOfSegments.CreateOrderedTreapFromRange(SegsNear, Comparer);

    261. 

  261. 			Console.Out.WriteLine(t.ToString(Mapper));

    262. 

  262. 			Console.Out.WriteLine(GetAllI(t));

    263. 

  263. 			for (int i = 0; i < SegsNear.Length; i++)

    264. 

  264. 			{

    265. 

  265. 				var segment = SegsNear[i];

    266. 

  266. 				var foundPos = t.Find(segment, Comparer);

    267. 

  267. 				var floorPos = t.GetFloorPos(segment, Comparer);

    268. 

  268. 				var ceilPos = t.GetCeilPos(segment, Comparer);

    269. 

  269. 				Console.Out.WriteLine(String.Join(" ", foundPos, t[floorPos].Start.Y, ceilPos.HasValue?t[ceilPos.Value].Start.Y:-1));

    270. 

  270. 				Assert.That(foundPos.HasValue);

    271. 

  271. 				Assert.That(foundPos.Value, Is.EqualTo(finds[i]));

    272. 

  272. 				Assert.That(t[floorPos].Start.Y, Is.EqualTo(floors[i]));

    273. 

  273. 				if (ceilPos == null)

    274. 

  274. 					Assert.That(ceils[i] == null);

    275. 

  275. 				else

    276. 

  276. 					Assert.That(t[ceilPos.Value].Start.Y, Is.EqualTo(ceils[i]));

    277. 

  277. 				

    278. 

  278. 			}

    279. 

  279. 		}

    280. 

  280. 

    281. 

  281. 		[Test]

    282. 

  282. 		public void SwapTest()

    283. 

  283. 		{

    284. 

  284. 			Comparer.X = 0.5;

    285. 

  285. 			var t = TreapOfSegments.CreateOrderedTreapFromRange(SegsNear, Comparer);

    286. 

  286. 			Console.Out.WriteLine(GetAllI(t));

    287. 

  287. 			t.Swap(SegsNear[3], SegsNear[1], Comparer);

    288. 

  288. 			Console.Out.WriteLine(GetAllI(t));

    289. 

  289. 		}

    290. 

  290. 

    291. 

  291. 		public static string GetAllI(ImplicitTreap<Segment> t)

    292. 

  292. 		{

    293. 

  293. 			return String.Join(" ",t.GetAllInfos().Select(i => i.Start.Y));

    294. 

  294. 		}

    295. 

  295. 	}

    296. 

  296. }
    297.