Four Algorithms

1. Analysis and Enhancement of Algorithms
in
Computational Geometry
Kasun Ranga Wijeweera
(krw19870829@gmail.com)
1

2. Talk Outline
• Introduction
• Literature Survey
• Triangulation of a Polygon
• Convex Partitioning of a Polygon
• Largest Circle inside a Polygon
• Visible Region of a Polygon
• Results and Discussion
• Conclusions
2

3. Introduction
3

4. What is Computational Geometry?
• Problems in classical geometry are addressed by
computerized algorithms.
• Challenges are problem representation, data structures,
algorithm design, and computational complexity.
4

5. Design Issues of Geometric Algorithms
• Running time
• Memory consumption
• Handling all possible cases
• Availability of a data structure
• Minimalist implementation
• Precision error
• Data type overflow
• Simplicity
5

6. Motivation
• Complicated algorithms are difficult to implement and debug.
• Sometimes, there are no suitable data structures available in
practice to implement those complex algorithms.
• Inventing simpler mathematical models to solve the already
solved problems has become a recent trend.
• Simpler algorithms can be easily implemented and useful for
scientists in other fields.
6

7. Triangulation of a Polygon
• Definition: The decomposition of a polygon into a set of non
overlapping triangles.
• Example:
7

8. Convex Partitioning of a Polygon
• Definition: The decomposition of a polygon into a set of non
overlapping convex pieces.
• Example:
8

9. Largest Circle inside a Polygon
• Definition: Finding the center of the largest circle inside an
arbitrary polygon.
• Example:
9

10. Visible Region of a Polygon
• Definition: Finding the region visible to a point inside the
polygon.
• Example:
10

11. Research Problem 1
• The basic triangulation algorithm can triangulate a polygon in
O (n4) time and O (n2) space with 100% accuracy.
• Even though more efficient algorithms are available in
literature, they are not 100% accurate due to the use of
floating point arithmetic.
• A simple and 100% accurate triangulation algorithm is
proposed with O (n3) time and O (n) space.
11

12. Research Problem 2
• Hertel Mehlhorn algorithm can partition a polygon into exact
convex pieces in O (n2) time and O (n2) space.
• Even though there are algorithms which produce smaller
number of convex pieces than the HM algorithm, they are
either less efficient or fail to produce exact convex pieces.
• A convex partitioning algorithm is proposed which produces
exact convex pieces in O (n3) time and O (n2) space.
• The proposed algorithm produces smaller number of convex
pieces than the HM algorithm and it is more efficient than the
other algorithms which produce exact convex pieces.
12

13. Research Problem 3
• The existing algorithms to find the largest circle inside a
polygon are restricted to convex polygons.
• An algorithm is proposed to find the largest circle inside an
arbitrary polygon in O (k * n) time and O (n) space where k
is the number of random points generated inside the
bounding rectangle of the polygon.
13

14. Research Problem 4
• The naïve algorithm to find the visible region inside a
polygon takes O (k * n) time and O (n) space where k is the
number of rays shot around the point.
• The output of this algorithm may contain lots of unnecessary
collinear points.
• The other existing algorithms are extremely complicated and
far from reality to provide correct implementations to them.
• An algorithm is proposed to find the visible region of a
polygon in O (n2) time and O (n) space.
• The proposed algorithm can find the exact visible region and
it does not produce unnecessary collinear points.
14

15. Literature Survey
15

16. Triangulation Algorithms
• Naïve approach: O (n4)
• Lennes (1911): O (n2)
• Garey et al. (1978): O (n log n)
• Hertel & Mehlhorn (1983): O (n log r), r reflex
• Chazelle & Incerpi (1984): O (n log s), s sinuosity
• Tarjan & Van Wyk (1988): O (n log log n)
• Clarkson et al. (1989): O (n log* n), randomized
• Toussaint (1990): O (n + nt0), t0 int. triangs.
• Kirkpatrick et al. (1990): O (n log* n), bnded. ints.
• Chazelle (1991): O (n)
• Seidel (1991): O (n log* n), randomized
• Amato et al. (2001): O (n), randomized
16

17. Convex Partitioning Algorithms
• Hertel Mehlhorn (1983): O (n2)
• Greene (1983): O (n4)
• Keil (1985): O (n3 log n)
• Chazelle (1985): O (n3)
• Lien et al. (2006): O (nr), r reflex
• Hongguang et al. (2015): O (nr), r reflex
17

18. Largest Circle Algorithms
• Daniel & Umberto (2017)
• Oscar (2017)
18

19. Visible Region Algorithms
• Naïve approach: O (k * n)
• Suri et al. (1986): O (n log n)
• Asano et al. (1986): O (n log n)
• Joe & Simpson (1987) : O (n)
• Vegter (1990): O (k log (n/k))
• Aronov et al. (2002): O (log2 n + k)
• Zarei & Ghodsi (2005): O (1 + min (h, k) log n + k)
• Heffernan & Mitchell (2006): O (n + h log h), h holes
• Francisc et al. (2014): O (n)
19

20. Triangulation of a Polygon
20

21. Proposed Algorithm 1
K. R. Wijeweera, S. R. Kodituwakku (2016), Accurate, Simple,
and Efficient Triangulation of a Polygon by Ear Removal
with Lowest Memory Consumption, Ceylon Journal of
Science, Volume 45 (Issue 3), pp. 65-76.
21

22. 22
0
1

23. 23
0
1

24. 24
0
1

25. 25
0
1

26. 26
0
1

27. 27
0
1

28. 28
0
1

29. 29
0
1

30. 30
0
1

31. 31
0
1

32. 32
0
1

33. 33
0
1

34. 34
0
1

35. 35
0
1

36. 36
0
1

37. 37
0
1

38. 38
0
1

39. 39
0
1

40. 40
0
1

41. 41
0
1

42. 42
0
1

43. 43
0
1

44. 44
0
1

45. 45
0
1

46. 46
0
1

47. 47
0
1

48. 48
0
1

49. 49
0
1

50. 50
0
1

51. 51
0
1

52. 52
0
1

53. 53
0
1

54. 54
01

55. 55
01

56. 56
01

57. 57
0
1

58. 58
0
1

59. 59
0
1

60. 60
0
1

61. 61
0
1

62. 62
0
1

63. 63
0
1

64. 64
0
1

65. 65
0
1

66. 66
0
1

67. 67
0
1

68. 68
0
1

69. 69
0
1

70. 70
0
1

71. 71
0
1

72. 72
0
1

73. 73
0
1

74. 74
0
1

75. 75
0
1

76. 76
0
1

77. 77
0
1

78. 78
0
1

79. 79
0
1

80. 80
0
1

81. 81
0
1

82. 82
0
1

83. 83
0
1

84. 84
0
1

85. 85
0
1

86. 86
0
1

87. 87
0
1

88. 88
0
1

89. 89
0
1

90. 90
0
1

91. 91
0
1

92. Convex Partitioning of a Polygon
92

93. Proposed Algorithm 2
K. R. Wijeweera, S. R. Kodituwakku (2017), Convex
Partitioning of a Polygon into Smaller Number of Pieces
with Lowest Memory Consumption, Ceylon Journal of
Science, Volume 46 (Issue 1), pp. 55-66.
93

94. 94
0
1

95. 95
0
1

96. 96
0
1

97. 97
0
1

98. 98
0
1

99. 99
0
1

100. 100
0
1

101. 101
0
1

102. 102
0
1

103. 103
0
1

104. 104
0
1

105. 105
0
1

106. 106
0
1

107. 107
0
1

108. 108
0
1

109. 109
0
1

110. 110
0
1

111. 111
0
1

112. 112
0
1

113. 113
0
1

114. 114
0
1

115. 115
0
1

116. 116
0
1

117. 117
0
1

118. 118
0
1

119. 119
0
1

120. 120
0
1

121. 121
0
1

122. 122
0
1

123. 123
0
1

124. 124
0
1

125. 125
0
1

126. 126
0
1

127. 127
0
1

128. 128
0
1

129. 129
0
1

130. 130
0
1

131. 131
0
1

132. 132
0
1

133. 133
0
1

134. 134
0
1

135. 135
0
1

136. 136
0
1

137. 137
0
1

138. 138
0
1

139. 139
0
1

140. 140
0
1

141. 141
0
1

142. 142
0
1

143. 143
0
1

144. 144
0
1

145. 145
0
1

146. 146
0
1

147. 147
0
1

148. 148
0
1

149. 149
0
1

150. 150
0
1

151. 151
0
1

152. 152
0
1

153. 153
0
1

154. 154
0
1

155. 155
0
1

156. 156
0
1

157. 157
0
1

158. Largest Circle inside a Polygon
158

159. Proposed Algorithm 3
K. R. Wijeweera, S. R. Kodituwakku (2015), An Algorithm to
Find the Largest Circle inside a Polygon, Ceylon Journal of
Science (Physical Sciences), Volume 19, pp. 45 - 54.
159

160. 160
0
1

161. 161
0
1

162. 162
0
1

163. 163
0
1

164. 164
0
1

165. 165
0
1

166. 166
0
1

167. 167
0
1

168. 168
0
1

169. 169
0
1

170. 170
0
1

171. 171
0
1

172. 172
0
1

173. 173
0
1

174. 174
0
1

175. 175
0
1

176. 176
0
1

177. 177
0
1

178. 178
0
1

179. 179
0
1

180. 180
0
1

181. 181
0
1

182. 182
0
1

183. 183
0
1

184. 184
0
1

185. 185
0
1

186. 186
0
1

187. 187
0
1

188. 188
0
1

189. 189
0
1

190. 190
0
1

191. 191
0
1

192. 192
0
1

193. 193
0
1

194. 194
0
1

195. 195
0
1

196. 196
0
1

197. 197
0
1

198. 198
0
1

199. 199
0
1

200. 200
0
1

201. 201
0
1

202. 202
0
1

203. 203
0
1

204. 204
0
1

205. 205
0
1

206. 206
0
1

207. 207
0
1

208. 208
0
1

209. 209
0
1

210. 210
0
1

211. 211
0
1

212. 212
0
1

213. 213
0
1

214. 214
0
1

215. 215
0
1

216. 216
0
1

217. 217
0
1

218. 218
0
1

219. 219
0
1

220. 220
0
1

221. 221
0
1

222. 222
0
1

223. 223
0
1

224. 224
0
1

225. 225
0
1

226. 226
0
1

227. Visible Region of a Polygon
227

228. Proposed Algorithm 4
K. R. Wijeweera, S. R. Kodituwakku (2015), An Algorithm to
Find the Visible Region of a Polygon, Ceylon Journal of
Science (Physical Sciences), Volume 19, pp. 33 - 44.
228

229. 229
0
1

230. 230
0
1

231. 231
0
1

232. 232
0
1

233. 233
0
1

234. 234
0
1

235. 235
0
1

236. 236
0
1

237. 237
0
1

238. 238
0
1

239. 239
0
1

240. 240
0
1

241. 241
0
1

242. 242
0
1

243. 243
0
1

244. 244
0
1

245. 245
0
1

246. 246
0
1

247. 247
0
1

248. 248
0
1

249. 249
0
1

250. 250
0
1

251. 251
0
1

252. 252
0
1

253. 253
0
1

254. 254
0
1

255. 255
0
1

256. 256
0
1

257. 257
0
1

258. 258
0
1

259. 259
0
1

260. 260
0
1

261. 261
0
1

262. 262
0
1

263. 263
0
1

264. 264
0
1

265. 265
0
1

266. 266
0
1

267. 267
0
1

268. 268
0
1

269. Results and Discussion
269

270. Triangulation Algorithm
• The proposed algorithm takes O (n3) time and needs O (n)
space.
• The proposed algorithm uses integer arithmetic only for
computations and therefore the precision error is avoided.
• The basic triangulation algorithm is the only algorithm that
uses integer arithmetic only.
• The other existing algorithms use floating point arithmetic
which leads to the precision error.
• The basic triangulation algorithm takes O (n4) time and needs
O (n2) space.
• The proposed algorithm uses integer arithmetic only and it is
better than the basic triangulation algorithm both in time and
space.
270

271. Convex Partitioning Algorithm
• The proposed algorithm takes O (n3) time and needs O (n2)
space.
• Hertel Mehlhorn algorithm is the fastest algorithm available
in literature.
• Hertel Mehlhorn algorithm takes O (n2) time and needs O
(n2) space.
• The proposed algorithm produces smaller number of pieces
than Hertel Mehlhorn algorithm even though it is slower.
• The proposed algorithm is faster than the other existing
algorithms that produce exact convex pieces.
271

272. Largest Circle Algorithm
• The proposed algorithm takes O (k * n) time and needs O (n)
space where k is the number of random points generated
inside the bounding rectangle.
• The proposed algorithm can find the largest circle inside any
arbitrary polygon.
• The existing algorithms are restricted to convex polygons.
272

273. Visible Region Algorithm
• The proposed algorithm takes O (n2) time and O (n) space.
• The naïve approach takes O (k * n) time and O (n) space
where k is the number of rays shot around the point.
• The output of the naïve algorithm contains lots of
unnecessary collinear points.
• There are number of theoretical algorithms available in
literature.
• However, they are extremely complicated and far from reality
to provide a computer implementation.
• The proposed algorithm is faster and more accurate than the
naïve approach and it does not produce unnecessary collinear
points.
273

274. Conclusions
274

275. Conclusions
• The proposed triangulation algorithm is faster than the basic
triangulation algorithm and also performs exact triangulation.
• The proposed convex partitioning algorithm produces smaller
number of pieces than the Hertel Mehlhorn algorithm and
also performs exact convex partitioning.
• The proposed largest circle algorithm works for any arbitrary
polygon.
• The proposed visible region algorithm is faster and more
accurate than the naïve approach and does not produce
unnecessary collinear points.
275

276. Thank you!
276