CoCalc -- shape_gen

GitHub Repository: yangliu28/swarm_formation_sim
Path: blob/master/loop-data2/shape_gen_script.py
¹⁰⁵ views
1
# script to generate files for the loop shapes
2
# each block of code generates one loop shape
3

4
import pickle
5
import os
6
import math
7
import pygame
8
import numpy as np
9

10
# general function to reset radian angle to [-pi, pi)
11
def reset_radian(radian):
12
    while radian >= math.pi:
13
        radian = radian - 2*math.pi
14
    while radian < -math.pi:
15
        radian = radian + 2*math.pi
16
    return radian
17

18
# general function to calculate next position node along a heading direction
19
def cal_next_node(node_poses, index_curr, heading_angle, rep_times):
20
    for _ in range(rep_times):
21
        index_next = index_curr + 1
22
        x = node_poses[index_curr][0] + 1.0*math.cos(heading_angle)
23
        y = node_poses[index_curr][1] + 1.0*math.sin(heading_angle)
24
        node_poses[index_next] = np.array([x,y])
25
        index_curr = index_next
26
    return index_next
27

28
# ##### script to generate 30-square #####
29
# filename = '30-square'
30
# swarm_size = 30
31
# node_poses = np.zeros((swarm_size, 2))
32
# x = 0.0
33
# y = 0.0
34
# # bottom side line
35
# # first node starting from bottom left corner
36
# node_poses[0] = np.array([0.0, 0.0])
37
# for i in range(1,8):
38
#     x = x + 1.0
39
#     node_poses[i] = np.array([x,y])
40
# # right line line
41
# x = x + 1.0 / math.sqrt(2)
42
# y = y + 1.0 / math.sqrt(2)
43
# node_poses[8] = np.array([x,y])
44
# for i in range(9,16):
45
#     y = y + 1.0
46
#     node_poses[i] = np.array([x,y])
47
# # top side line
48
# for i in range(16,23):
49
#     x = x - 1.0
50
#     node_poses[i] = np.array([x,y])
51
# # left side line
52
# x = x - 1.0 / math.sqrt(2)
53
# y = y - 1.0 / math.sqrt(2)
54
# node_poses[23] = np.array([x,y])
55
# for i in range(24,30):
56
#     y = y - 1.0
57
#     node_poses[i] = np.array([x,y])
58
# print("node_poses: {}".format(node_poses))
59
# with open(filename, 'w') as f:
60
#     pickle.dump(node_poses, f)
61

62

63
# ##### script to generate 100-square #####
64
# filename = '100-square'
65
# swarm_size = 100
66
# node_poses = np.zeros((swarm_size, 2))
67
# x = 0.0
68
# y = 0.0
69
# # bottom side line
70
# node_poses[0] = np.array([0.0, 0.0])
71
# for i in range(1,26):
72
#     x = x + 1.0
73
#     node_poses[i] = np.array([x,y])
74
# # right line line
75
# for i in range(26,51):
76
#     y = y + 1.0
77
#     node_poses[i] = np.array([x,y])
78
# # top side line
79
# for i in range(51,76):
80
#     x = x - 1.0
81
#     node_poses[i] = np.array([x,y])
82
# # left side line
83
# for i in range(76,100):
84
#     y = y - 1.0
85
#     node_poses[i] = np.array([x,y])
86
# print("node_poses: {}".format(node_poses))
87
# with open(filename, 'w') as f:
88
#     pickle.dump(node_poses, f)
89

90

91
# ##### script to generate 30-circle #####
92
# filename = '30-circle'
93
# swarm_size = 30
94
# node_poses = np.zeros((swarm_size, 2))
95
# center = np.zeros(2)
96
# radius = 0.5 / math.sin(math.pi/swarm_size)
97
# # first node starting from left most position
98
# for i in range(swarm_size):
99
#     ori = -math.pi + 2*math.pi/swarm_size * i
100
#     node_poses[i] = center + np.array([radius*math.cos(ori), radius*math.sin(ori)])
101
# print("node_poses: {}".format(node_poses))
102
# with open(filename, 'w') as f:
103
#     pickle.dump(node_poses, f)
104

105

106
# ##### script to generate 100-circle #####
107
# filename = '100-circle'
108
# swarm_size = 100
109
# node_poses = np.zeros((swarm_size, 2))
110
# center = np.zeros(2)
111
# radius = 0.5 / math.sin(math.pi/swarm_size)
112
# # first node starting from left most position
113
# for i in range(swarm_size):
114
#     ori = -math.pi + 2*math.pi/swarm_size * i
115
#     node_poses[i] = center + np.array([radius*math.cos(ori), radius*math.sin(ori)])
116
# print("node_poses: {}".format(node_poses))
117
# with open(filename, 'w') as f:
118
#     pickle.dump(node_poses, f)
119

120

121
# ##### script to generate 30-triangle #####
122
# filename = '30-triangle'
123
# swarm_size = 30
124
# node_poses = np.zeros((swarm_size, 2))
125
# # first node is at bottom left corner
126
# x = 0.0
127
# y = 0.0
128
# node_poses[0] = np.array([x,y])
129
# for i in range(1,11):
130
#     x = x + 1.0
131
#     node_poses[i] = np.array([x,y])
132
# for i in range(11,21):
133
#     x = x + 1.0 * math.cos(math.pi*2/3)
134
#     y = y + 1.0 * math.sin(math.pi*2/3)
135
#     node_poses[i] = np.array([x,y])
136
# for i in range(21, 30):
137
#     x = x + 1.0 * math.cos(-math.pi*2/3)
138
#     y = y + 1.0 * math.sin(-math.pi*2/3)
139
#     node_poses[i] = np.array([x,y])
140
# print("node_poses: {}".format(node_poses))
141
# with open(filename, 'w') as f:
142
#     pickle.dump(node_poses, f)
143

144

145
# ##### script to generate 100-triangle #####
146
# filename = '100-triangle'
147
# swarm_size = 100
148
# node_poses = np.zeros((swarm_size, 2))
149
# side_angle = math.acos(17.0/33.0)
150
# # first node is at bottom left corner
151
# x = 0.0
152
# y = 0.0
153
# node_poses[0] = np.array([x,y])
154
# for i in range(1,35):
155
#     x = x + 1.0
156
#     node_poses[i] = np.array([x,y])
157
# for i in range(35,68):
158
#     x = x + 1.0 * math.cos(math.pi-side_angle)
159
#     y = y + 1.0 * math.sin(math.pi-side_angle)
160
#     node_poses[i] = np.array([x,y])
161
# for i in range(68, 100):
162
#     x = x + 1.0 * math.cos(-math.pi+side_angle)
163
#     y = y + 1.0 * math.sin(-math.pi+side_angle)
164
#     node_poses[i] = np.array([x,y])
165
# print("node_poses: {}".format(node_poses))
166
# with open(filename, 'w') as f:
167
#     pickle.dump(node_poses, f)
168

169

170
# ##### script to generate 30-star #####
171
# filename = '30-star'
172
# swarm_size = 30
173
# node_poses = np.zeros((swarm_size, 2))
174
# outer_angle = 2*math.pi / 5.0
175
# devia_right = outer_angle
176
# devia_left = 2*outer_angle
177
# # first node is at bottom left corner
178
# heading_angle = outer_angle / 2.0  # current heading
179
# heading_dir = 0  # current heading direction: 0 for left, 1 for right
180
# seg_count = 0  # current segment count
181
# for i in range(1,swarm_size):
182
#     node_poses[i] = (node_poses[i-1] +
183
#         np.array([math.cos(heading_angle), math.sin(heading_angle)]))
184
#     seg_count = seg_count + 1
185
#     if seg_count == 3:
186
#         seg_count = 0
187
#         if heading_dir == 0:
188
#             heading_angle = reset_radian(heading_angle - devia_right)
189
#             heading_dir = 1
190
#         else:
191
#             heading_angle = reset_radian(heading_angle + devia_left)
192
#             heading_dir = 0
193
# print(node_poses)
194
# with open(filename, 'w') as f:
195
#     pickle.dump(node_poses, f)
196

197

198
# ##### script to generate 100-star #####
199
# filename = '100-star'
200
# swarm_size = 100
201
# node_poses = np.zeros((swarm_size, 2))
202
# outer_angle = 2*math.pi / 5.0
203
# devia_right = outer_angle
204
# devia_left = 2*outer_angle
205
# # first node is at bottom left corner
206
# heading_angle = outer_angle / 2.0  # current heading
207
# heading_dir = 0  # current heading direction: 0 for left, 1 for right
208
# seg_count = 0  # current segment count
209
# for i in range(1,swarm_size):
210
#     node_poses[i] = (node_poses[i-1] +
211
#         np.array([math.cos(heading_angle), math.sin(heading_angle)]))
212
#     seg_count = seg_count + 1
213
#     if seg_count == 10:
214
#         seg_count = 0
215
#         if heading_dir == 0:
216
#             heading_angle = reset_radian(heading_angle - devia_right)
217
#             heading_dir = 1
218
#         else:
219
#             heading_angle = reset_radian(heading_angle + devia_left)
220
#             heading_dir = 0
221
# print(node_poses)
222
# with open(filename, 'w') as f:
223
#     pickle.dump(node_poses, f)
224

225

226
# ##### script to generate 30-airplane #####
227
# filename = '30-airplane'
228
# swarm_size = 30
229
# node_poses = np.zeros((swarm_size, 2))
230
# # first node is at bottom center
231
# node_index = 0  # current sitting node
232
# heading_angle = - (14.0*math.pi)/180.0
233
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
234
# heading_angle = reset_radian(heading_angle + (130.0*math.pi)/180.0)
235
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
236
# heading_angle = reset_radian(heading_angle - (42.0*math.pi)/180.0)
237
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
238
# heading_angle = reset_radian(heading_angle - (94.0*math.pi)/180.0)
239
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
240
# heading_angle = reset_radian(heading_angle + (106.0*math.pi)/180.0)
241
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
242
# heading_angle = reset_radian(heading_angle + (55.0*math.pi)/180.0)
243
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
244
# heading_angle = reset_radian(heading_angle - (35.0*math.pi)/180.0)
245
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
246
# # half the airplane constructed, mirror the next half
247
# axis_vect = node_poses[node_index] - node_poses[0]
248
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
249
# for i in range(1,15):
250
#     old_vect = node_poses[i] - node_poses[0]
251
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
252
# print(node_poses)
253
# with open(filename, 'w') as f:
254
#     pickle.dump(node_poses, f)
255

256

257
# ##### script to generate 100-airplane #####
258
# filename = '100-airplane'
259
# swarm_size = 100
260
# node_poses = np.zeros((swarm_size, 2))
261
# # first node is at bottom center
262
# node_index = 0  # current sitting node
263
# heading_angle = - (18.0*math.pi)/180.0
264
# node_index = cal_next_node(node_poses, node_index, heading_angle, 6)
265
# heading_angle = reset_radian(heading_angle + (135.0*math.pi)/180.0)
266
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
267
# heading_angle = reset_radian(heading_angle - (42.0*math.pi)/180.0)
268
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
269
# heading_angle = reset_radian(heading_angle - (94.0*math.pi)/180.0)
270
# node_index = cal_next_node(node_poses, node_index, heading_angle, 9)
271
# heading_angle = reset_radian(heading_angle + (106.0*math.pi)/180.0)
272
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
273
# heading_angle = reset_radian(heading_angle + (55.0*math.pi)/180.0)
274
# node_index = cal_next_node(node_poses, node_index, heading_angle, 12)
275
# heading_angle = reset_radian(heading_angle - (40.0*math.pi)/180.0)
276
# node_index = cal_next_node(node_poses, node_index, heading_angle, 10)
277
# # half the airplane constructed, mirror the next half
278
# axis_vect = node_poses[node_index] - node_poses[0]
279
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
280
# for i in range(1,50):
281
#     old_vect = node_poses[i] - node_poses[0]
282
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
283
# print(node_poses)
284
# with open(filename, 'w') as f:
285
#     pickle.dump(node_poses, f)
286

287

288
# ##### script to generate 30-cross #####
289
# filename = '30-cross'
290
# swarm_size = 30
291
# node_poses = np.zeros((swarm_size, 2))
292
# node_index = 0
293
# heading_angle = 0.0
294
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
295
# heading_angle = math.pi/2
296
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
297
# heading_angle = 0.0
298
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
299
# heading_angle = math.pi/2
300
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
301
# heading_angle = -math.pi
302
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
303
# heading_angle = math.pi/2
304
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
305
# heading_angle = -math.pi
306
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
307
# heading_angle = -math.pi/2
308
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
309
# heading_angle = -math.pi
310
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
311
# heading_angle = -math.pi/2
312
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
313
# heading_angle = 0.0
314
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
315
# heading_angle = -math.pi/2
316
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
317
# print(node_index)
318
# print(node_poses)
319
# with open(filename, 'w') as f:
320
#     pickle.dump(node_poses, f)
321

322

323
# ##### script to generate 100-cross #####
324
# filename = '100-cross'
325
# swarm_size = 100
326
# node_poses = np.zeros((swarm_size, 2))
327
# node_index = 0
328
# heading_angle = 0.0
329
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
330
# heading_angle = math.pi/2
331
# node_index = cal_next_node(node_poses, node_index, heading_angle, 17)
332
# heading_angle = 0.0
333
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
334
# heading_angle = math.pi/2
335
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
336
# heading_angle = -math.pi
337
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
338
# heading_angle = math.pi/2
339
# node_index = cal_next_node(node_poses, node_index, heading_angle, 7)
340
# heading_angle = -math.pi
341
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
342
# heading_angle = -math.pi/2
343
# node_index = cal_next_node(node_poses, node_index, heading_angle, 7)
344
# heading_angle = -math.pi
345
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
346
# heading_angle = -math.pi/2
347
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
348
# heading_angle = 0.0
349
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
350
# heading_angle = -math.pi/2
351
# node_index = cal_next_node(node_poses, node_index, heading_angle, 16)
352
# print(node_index)
353
# print(node_poses)
354
# with open(filename, 'w') as f:
355
#     pickle.dump(node_poses, f)
356

357

358
# ##### script to generate 30-hand #####
359
# filename = '30-hand'
360
# swarm_size = 30
361
# node_poses = np.zeros((swarm_size, 2))
362
# node_index = 0
363
# heading_angle = 0.0
364
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
365
# heading_angle = reset_radian(heading_angle + (20.0*math.pi)/180.0)
366
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
367
# heading_angle = reset_radian(heading_angle + (20.0*math.pi)/180.0)
368
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
369
# heading_angle = reset_radian(heading_angle + (55.0*math.pi)/180.0)
370
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
371
# # small finger
372
# heading_angle = reset_radian(heading_angle - (15.0*math.pi)/180.0)
373
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
374
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
375
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
376
# heading_angle = reset_radian(heading_angle + (85.0*math.pi)/180.0)
377
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
378
# # middle finger(no ring finger)
379
# heading_angle = reset_radian(heading_angle - (147.0*math.pi)/180.0)
380
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
381
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
382
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
383
# heading_angle = reset_radian(heading_angle + (85.0*math.pi)/180.0)
384
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
385
# # index finger
386
# heading_angle = reset_radian(heading_angle - (147.0*math.pi)/180.0)
387
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
388
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
389
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
390
# heading_angle = reset_radian(heading_angle + (85.0*math.pi)/180.0)
391
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
392
# # thumb
393
# heading_angle = reset_radian(heading_angle - (125.0*math.pi)/180.0)
394
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
395
# heading_angle = reset_radian(heading_angle + (85.0*math.pi)/180.0)
396
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
397
# heading_angle = reset_radian(heading_angle + (85.0*math.pi)/180.0)
398
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
399
# print(node_index)
400
# print(node_poses)
401
# with open(filename, 'w') as f:
402
#     pickle.dump(node_poses, f)
403

404

405
# ##### script to generate 100-hand #####
406
# filename = '100-hand'
407
# swarm_size = 100
408
# node_poses = np.zeros((swarm_size, 2))
409
# node_index = 0
410
# heading_angle = 0.0
411
# node_index = cal_next_node(node_poses, node_index, heading_angle, 6)
412
# heading_angle = reset_radian(heading_angle + (45.0*math.pi)/180.0)
413
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
414
# heading_angle = reset_radian(heading_angle + (35.0*math.pi)/180.0)
415
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
416
# # small finger
417
# heading_angle = reset_radian(heading_angle - (15.0*math.pi)/180.0)
418
# node_index = cal_next_node(node_poses, node_index, heading_angle, 6)
419
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
420
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
421
# heading_angle = reset_radian(heading_angle + (80.0*math.pi)/180.0)
422
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
423
# heading_angle = reset_radian(heading_angle + (44.0*math.pi)/180.0)
424
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
425
# heading_angle = reset_radian(heading_angle - (80.0*math.pi)/180.0)
426
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
427
# # ring finger
428
# heading_angle = reset_radian(heading_angle - (80.0*math.pi)/180.0)
429
# node_index = cal_next_node(node_poses, node_index, heading_angle, 7)
430
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
431
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
432
# heading_angle = reset_radian(heading_angle + (80.0*math.pi)/180.0)
433
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
434
# heading_angle = reset_radian(heading_angle + (44.0*math.pi)/180.0)
435
# node_index = cal_next_node(node_poses, node_index, heading_angle, 7)
436
# heading_angle = reset_radian(heading_angle - (80.0*math.pi)/180.0)
437
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
438
# # middle finger
439
# heading_angle = reset_radian(heading_angle - (80.0*math.pi)/180.0)
440
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
441
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
442
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
443
# heading_angle = reset_radian(heading_angle + (80.0*math.pi)/180.0)
444
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
445
# heading_angle = reset_radian(heading_angle + (44.0*math.pi)/180.0)
446
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
447
# heading_angle = reset_radian(heading_angle - (80.0*math.pi)/180.0)
448
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
449
# # index finger
450
# heading_angle = reset_radian(heading_angle - (80.0*math.pi)/180.0)
451
# node_index = cal_next_node(node_poses, node_index, heading_angle, 7)
452
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
453
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
454
# heading_angle = reset_radian(heading_angle + (80.0*math.pi)/180.0)
455
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
456
# heading_angle = reset_radian(heading_angle + (44.0*math.pi)/180.0)
457
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
458
# heading_angle = reset_radian(heading_angle - (10.0*math.pi)/180.0)
459
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
460
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
461
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
462
# # thumb
463
# heading_angle = reset_radian(heading_angle - (80.0*math.pi)/180.0)
464
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
465
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
466
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
467
# heading_angle = reset_radian(heading_angle + (80.0*math.pi)/180.0)
468
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
469
# heading_angle = reset_radian(heading_angle + (40.0*math.pi)/180.0)
470
# node_index = cal_next_node(node_poses, node_index, heading_angle, 9)
471
# heading_angle = reset_radian(heading_angle + (20.0*math.pi)/180.0)
472
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
473
# print(node_index)
474
# print(node_poses)
475
# with open(filename, 'w') as f:
476
#     pickle.dump(node_poses, f)
477

478

479
# ##### script to generate 30-wrench #####
480
# filename = '30-wrench'
481
# swarm_size = 30
482
# node_poses = np.zeros((swarm_size, 2))
483
# node_index = 0
484
# heading_angle = 0.0
485
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
486
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
487
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
488
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
489
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
490
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
491
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
492
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
493
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
494
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
495
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
496
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
497
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
498
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
499
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
500
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
501
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
502
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
503
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
504
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
505
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
506
# # half the wrench is finished, mirror the next half
507
# axis_vect = node_poses[node_index] - node_poses[0]
508
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
509
# for i in range(1,15):
510
#     old_vect = node_poses[i] - node_poses[0]
511
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
512
# print(node_index)
513
# print(node_poses)
514
# with open(filename, 'w') as f:
515
#     pickle.dump(node_poses, f)
516

517

518
# ##### script to generate 100-wrench #####
519
# filename = '100-wrench'
520
# swarm_size = 100
521
# node_poses = np.zeros((swarm_size, 2))
522
# node_index = 0
523
# heading_angle = 0.0
524
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
525
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
526
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
527
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
528
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
529
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
530
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
531
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
532
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
533
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
534
# node_index = cal_next_node(node_poses, node_index, heading_angle, 20)
535
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
536
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
537
# heading_angle = reset_radian(heading_angle + (50.0*math.pi)/180.0)
538
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
539
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
540
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
541
# heading_angle = reset_radian(heading_angle + (90.0*math.pi)/180.0)
542
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
543
# heading_angle = reset_radian(heading_angle - (50.0*math.pi)/180.0)
544
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
545
# # half the wrench is finished, mirror the next half
546
# axis_vect = node_poses[node_index] - node_poses[0]
547
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
548
# for i in range(1,50):
549
#     old_vect = node_poses[i] - node_poses[0]
550
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
551
# print(node_index)
552
# print(node_poses)
553
# with open(filename, 'w') as f:
554
#     pickle.dump(node_poses, f)
555

556

557
# ##### script to generate 30-goblet #####
558
# filename = '30-goblet'
559
# swarm_size = 30
560
# node_poses = np.zeros((swarm_size, 2))
561
# node_index = 0
562
# arc_angle = 10.8  # default 11.25 deg
563
# heading_angle = 0.0
564
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
565
# heading_angle = reset_radian(heading_angle + (135*math.pi)/180.0)
566
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
567
# heading_angle = reset_radian(heading_angle + (30*math.pi)/180.0)
568
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
569
# heading_angle = math.pi/2
570
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
571
# heading_angle = (arc_angle*math.pi)/180.0
572
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
573
# heading_angle = reset_radian(heading_angle + (2*arc_angle*math.pi)/180.0)
574
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
575
# heading_angle = reset_radian(heading_angle + (2*arc_angle*math.pi)/180.0)
576
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
577
# heading_angle = reset_radian(heading_angle + (2*arc_angle*math.pi)/180.0)
578
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
579
# heading_angle = math.pi/2
580
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
581
# heading_angle = -math.pi
582
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
583
# # half the wrench is finished, mirror the next half
584
# axis_vect = node_poses[node_index] - node_poses[0]
585
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
586
# for i in range(1,15):
587
#     old_vect = node_poses[i] - node_poses[0]
588
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
589
# print(node_index)
590
# print(node_poses)
591
# with open(filename, 'w') as f:
592
#     pickle.dump(node_poses, f)
593

594

595
# ##### script to generate 100-goblet #####
596
# filename = '100-goblet'
597
# swarm_size = 100
598
# node_poses = np.zeros((swarm_size, 2))
599
# node_index = 0
600
# arc_angle = 4.1
601
# heading_angle = 0.0
602
# node_index = cal_next_node(node_poses, node_index, heading_angle, 7)
603
# heading_angle = (120*math.pi)/180.0
604
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
605
# heading_angle = -math.pi
606
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
607
# heading_angle = math.pi/2
608
# node_index = cal_next_node(node_poses, node_index, heading_angle, 10)
609
# heading_angle = -(arc_angle*math.pi)/180.0
610
# for _ in range(10):
611
#     heading_angle = reset_radian(heading_angle + (2*arc_angle*math.pi)/180.0)
612
#     node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
613
# heading_angle = math.pi/2
614
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
615
# heading_angle = -math.pi
616
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
617
# # half the wrench is finished, mirror the next half
618
# axis_vect = node_poses[node_index] - node_poses[0]
619
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
620
# for i in range(1,50):
621
#     old_vect = node_poses[i] - node_poses[0]
622
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
623
# print(node_index)
624
# print(node_poses)
625
# with open(filename, 'w') as f:
626
#     pickle.dump(node_poses, f)
627

628

629
# ##### script to generate 30-lamp #####
630
# filename = '30-lamp'
631
# swarm_size = 30
632
# node_poses = np.zeros((swarm_size, 2))
633
# node_index = 0
634
# heading_angle = 0.0
635
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
636
# heading_angle = (132*math.pi)/180.0
637
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
638
# heading_angle = ((180-15)*math.pi)/180.0
639
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
640
# heading_angle = math.pi/2
641
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
642
# heading_angle = 0.0
643
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
644
# heading_angle = (110*math.pi)/180.0
645
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
646
# heading_angle = -math.pi
647
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
648
# # half the wrench is finished, mirror the next half
649
# axis_vect = node_poses[node_index] - node_poses[0]
650
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
651
# for i in range(1,15):
652
#     old_vect = node_poses[i] - node_poses[0]
653
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
654
# print(node_index)
655
# print(node_poses)
656
# with open(filename, 'w') as f:
657
#     pickle.dump(node_poses, f)
658

659

660
# ##### script to generate 100-lamp #####
661
# filename = '100-lamp'
662
# swarm_size = 100
663
# node_poses = np.zeros((swarm_size, 2))
664
# node_index = 0
665
# heading_angle = 0.0
666
# node_index = cal_next_node(node_poses, node_index, heading_angle, 6)
667
# heading_angle = (100*math.pi)/180.0
668
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
669
# heading_angle = (140*math.pi)/180.0
670
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
671
# heading_angle = (160*math.pi)/180.0
672
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
673
# heading_angle = (175*math.pi)/180.0
674
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
675
# heading_angle = math.pi/2
676
# node_index = cal_next_node(node_poses, node_index, heading_angle, 7)
677
# heading_angle = 0.0
678
# node_index = cal_next_node(node_poses, node_index, heading_angle, 10)
679
# heading_angle = (110*math.pi)/180.0
680
# node_index = cal_next_node(node_poses, node_index, heading_angle, 15)
681
# heading_angle = -math.pi
682
# node_index = cal_next_node(node_poses, node_index, heading_angle, 6)
683
# # half the wrench is finished, mirror the next half
684
# axis_vect = node_poses[node_index] - node_poses[0]
685
# axis_vect = axis_vect / np.linalg.norm(axis_vect)
686
# for i in range(1,50):
687
#     old_vect = node_poses[i] - node_poses[0]
688
#     node_poses[-i] = 2*np.dot(axis_vect, old_vect)*axis_vect - old_vect
689
# print(node_index)
690
# print(node_poses)
691
# with open(filename, 'w') as f:
692
#     pickle.dump(node_poses, f)
693

694

695
# ##### script to generate 30-K #####
696
# filename = '30-K'
697
# swarm_size = 30
698
# node_poses = np.zeros((swarm_size, 2))
699
# node_index = 0
700
# angle_up = (50*math.pi)/180.0
701
# angle_down = -(50*math.pi)/180.0
702
# heading_angle = 0.0
703
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
704
# heading_angle = math.pi/2
705
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
706
# heading_angle = angle_down
707
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
708
# heading_angle = angle_up
709
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
710
# heading_angle = reset_radian(angle_down + math.pi)
711
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
712
# heading_angle = angle_up
713
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
714
# heading_angle = reset_radian(angle_down + math.pi)
715
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
716
# heading_angle = reset_radian(angle_up - math.pi)
717
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
718
# heading_angle = math.pi/2
719
# node_index = cal_next_node(node_poses, node_index, heading_angle, 2)
720
# heading_angle = -math.pi
721
# node_index = cal_next_node(node_poses, node_index, heading_angle, 1)
722
# heading_angle = -math.pi/2
723
# node_index = cal_next_node(node_poses, node_index, heading_angle, 6)
724
# print(node_index)
725
# print(node_poses)
726
# with open(filename, 'w') as f:
727
#     pickle.dump(node_poses, f)
728

729

730
# ##### script to generate 100-K #####
731
# filename = '100-K'
732
# swarm_size = 100
733
# node_poses = np.zeros((swarm_size, 2))
734
# node_index = 0
735
# angle_up = (49*math.pi)/180.0
736
# angle_down = -(49*math.pi)/180.0
737
# heading_angle = 0.0
738
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
739
# heading_angle = math.pi/2
740
# node_index = cal_next_node(node_poses, node_index, heading_angle, 6)
741
# heading_angle = angle_up
742
# node_index = cal_next_node(node_poses, node_index, heading_angle, 3)
743
# heading_angle = angle_down
744
# node_index = cal_next_node(node_poses, node_index, heading_angle, 10)
745
# heading_angle = 0.0
746
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
747
# heading_angle = reset_radian(angle_down + math.pi)
748
# node_index = cal_next_node(node_poses, node_index, heading_angle, 14)
749
# heading_angle = angle_up
750
# node_index = cal_next_node(node_poses, node_index, heading_angle, 11)
751
# heading_angle = -math.pi
752
# node_index = cal_next_node(node_poses, node_index, heading_angle, 5)
753
# heading_angle = reset_radian(angle_up - math.pi)
754
# node_index = cal_next_node(node_poses, node_index, heading_angle, 10)
755
# heading_angle = math.pi/2
756
# node_index = cal_next_node(node_poses, node_index, heading_angle, 8)
757
# heading_angle = -math.pi
758
# node_index = cal_next_node(node_poses, node_index, heading_angle, 4)
759
# heading_angle = -math.pi/2
760
# node_index = cal_next_node(node_poses, node_index, heading_angle, 19)
761
# print(node_index)
762
# print(node_poses)
763
# with open(filename, 'w') as f:
764
#     pickle.dump(node_poses, f)
765

766

767

768
pygame.init()
769
# find the right world and screen sizes
770
x_max, y_max = np.max(node_poses, axis=0)
771
x_min, y_min = np.min(node_poses, axis=0)
772
pixel_per_length = 30
773
world_size = (x_max - x_min + 2.0, y_max - y_min + 2.0)
774
screen_size = (int(world_size[0])*pixel_per_length, int(world_size[1])*pixel_per_length)
775
# convert node poses in the world to disp poses on screen
776
def cal_disp_poses():
777
    poses_temp = np.zeros((swarm_size, 2))
778
    # shift the loop to the middle of the world
779
    middle = np.array([(x_max+x_min)/2.0, (y_max+y_min)/2.0])
780
    for i in range(swarm_size):
781
        poses_temp[i] = (node_poses[i] - middle +
782
            np.array([world_size[0]/2.0, world_size[1]/2.0]))
783
    # convert to display coordinates
784
    poses_temp[:,0] = poses_temp[:,0] / world_size[0]
785
    poses_temp[:,0] = poses_temp[:,0] * screen_size[0]
786
    poses_temp[:,1] = poses_temp[:,1] / world_size[1]
787
    poses_temp[:,1] = 1.0 - poses_temp[:,1]
788
    poses_temp[:,1] = poses_temp[:,1] * screen_size[1]
789
    return poses_temp.astype(int)
790
disp_poses = cal_disp_poses()
791
# draw the loop shape on pygame window
792
color_white = (255,255,255)
793
color_black = (0,0,0)
794
screen = pygame.display.set_mode(screen_size)
795
screen.fill(color_white)
796
for i in range(swarm_size):
797
    pygame.draw.circle(screen, color_black, disp_poses[i], 5, 0)
798
for i in range(swarm_size-1):
799
    pygame.draw.line(screen, color_black, disp_poses[i], disp_poses[i+1], 2)
800
pygame.draw.line(screen, color_black, disp_poses[0], disp_poses[swarm_size-1], 2)
801
pygame.display.update()
802

803
# # save the screen as image
804
# filepath = os.path.join('images',filename+'.png')
805
# pygame.image.save(screen, filepath)
806

807
raw_input("<Press ENTER to exit>")
808

809

810

811
Product

Resources

Company
