← Back to branch summary

~ubuntu-branches/debian/jessie/libccd/jessie

« back to all changes in this revision

Viewing changes to src/testsuites/polytope.c

  • Committer: Package Import Robot
  • Author(s): Jose Luis Rivero
  • Date: 2014-03-24 16:51:48 UTC
  • Revision ID: package-import@ubuntu.com-20140324165148-mfno979f58rv322z
Tags: upstream-2.0
Import upstream version 2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/testsuites/polytope.c
 
1
//#undef NDEBUG
 
2
#include <cu/cu.h>
 
3
#include "../polytope.h"
 
4
#include "../dbg.h"
 
5
 
 
6
TEST(ptSetUp)
 
7
{
 
8
}
 
9
 
 
10
TEST(ptTearDown)
 
11
{
 
12
}
 
13
 
 
14
 
 
15
TEST(ptCreate1)
 
16
{
 
17
    ccd_pt_t pt;
 
18
    ccd_pt_vertex_t *v[3];
 
19
    ccd_pt_edge_t *e[3];
 
20
    ccd_pt_face_t *f;
 
21
    ccd_vec3_t u;
 
22
    int res, i;
 
23
 
 
24
    DBG2("------");
 
25
 
 
26
    ccdPtInit(&pt);
 
27
    ccdPtDestroy(&pt);
 
28
 
 
29
 
 
30
    ccdPtInit(&pt);
 
31
 
 
32
    ccdVec3Set(&u, -1., -1., 0.);
 
33
    v[0] = ccdPtAddVertexCoords(&pt, -1., -1., 0.);
 
34
    assertTrue(ccdVec3Eq(&u, &v[0]->v.v));
 
35
 
 
36
    ccdVec3Set(&u, 1., 0., 0.);
 
37
    v[1] = ccdPtAddVertexCoords(&pt, 1., 0., 0.);
 
38
    assertTrue(ccdVec3Eq(&u, &v[1]->v.v));
 
39
 
 
40
    ccdVec3Set(&u, 0., 0., 1.);
 
41
    v[2] = ccdPtAddVertexCoords(&pt, 0., 0., 1.);
 
42
    assertTrue(ccdVec3Eq(&u, &v[2]->v.v));
 
43
 
 
44
    for (i = 0; i < 3; i++){
 
45
        assertTrue(ccdEq(v[i]->dist, ccdVec3Len2(&v[i]->v.v)));
 
46
    }
 
47
 
 
48
 
 
49
    e[0] = ccdPtAddEdge(&pt, v[0], v[1]);
 
50
    e[1] = ccdPtAddEdge(&pt, v[1], v[2]);
 
51
    e[2] = ccdPtAddEdge(&pt, v[2], v[0]);
 
52
    for (i = 0; i < 3; i++){
 
53
        DBG("e[%d]->dist: %lf", i, e[i]->dist);
 
54
        DBG_VEC3(&e[i]->witness, "     ->witness: ");
 
55
    }
 
56
 
 
57
    f = ccdPtAddFace(&pt, e[0], e[1], e[2]);
 
58
    DBG("f->dist: %lf", f->dist);
 
59
    DBG_VEC3(&f->witness, "     ->witness: ");
 
60
 
 
61
    for (i = 0; i < 3; i++){
 
62
        res = ccdPtDelVertex(&pt, v[i]);
 
63
        assertFalse(res == 0);
 
64
        res = ccdPtDelEdge(&pt, e[i]);
 
65
        assertFalse(res == 0);
 
66
    }
 
67
 
 
68
    ccdPtDelFace(&pt, f);
 
69
    for (i = 0; i < 3; i++){
 
70
        res = ccdPtDelVertex(&pt, v[i]);
 
71
        assertFalse(res == 0);
 
72
    }
 
73
    for (i = 0; i < 3; i++){
 
74
        res = ccdPtDelEdge(&pt, e[i]);
 
75
        assertTrue(res == 0);
 
76
    }
 
77
    for (i = 0; i < 3; i++){
 
78
        res = ccdPtDelVertex(&pt, v[i]);
 
79
        assertTrue(res == 0);
 
80
    }
 
81
 
 
82
    v[0] = ccdPtAddVertexCoords(&pt, -1., -1., 0.);
 
83
    v[1] = ccdPtAddVertexCoords(&pt, 1., 0., 0.);
 
84
    v[2] = ccdPtAddVertexCoords(&pt, 0., 0., 1.);
 
85
 
 
86
    e[0] = ccdPtAddEdge(&pt, v[0], v[1]);
 
87
    e[1] = ccdPtAddEdge(&pt, v[1], v[2]);
 
88
    e[2] = ccdPtAddEdge(&pt, v[2], v[0]);
 
89
 
 
90
    f = ccdPtAddFace(&pt, e[0], e[1], e[2]);
 
91
 
 
92
    ccdPtDestroy(&pt);
 
93
}
 
94
 
 
95
TEST(ptCreate2)
 
96
{
 
97
    ccd_pt_t pt;
 
98
    ccd_pt_vertex_t *v[4];
 
99
    ccd_pt_edge_t *e[6];
 
100
    ccd_pt_face_t *f[4];
 
101
    ccd_vec3_t u;
 
102
    int res, i;
 
103
 
 
104
    DBG2("------");
 
105
 
 
106
    ccdPtInit(&pt);
 
107
 
 
108
    ccdVec3Set(&u, -1., -1., 0.);
 
109
    v[0] = ccdPtAddVertexCoords(&pt, -1., -1., 0.);
 
110
    assertTrue(ccdVec3Eq(&u, &v[0]->v.v));
 
111
 
 
112
    ccdVec3Set(&u, 1., 0., 0.);
 
113
    v[1] = ccdPtAddVertexCoords(&pt, 1., 0., 0.);
 
114
    assertTrue(ccdVec3Eq(&u, &v[1]->v.v));
 
115
 
 
116
    ccdVec3Set(&u, 0., 0., 1.);
 
117
    v[2] = ccdPtAddVertexCoords(&pt, 0., 0., 1.);
 
118
    assertTrue(ccdVec3Eq(&u, &v[2]->v.v));
 
119
 
 
120
    ccdVec3Set(&u, 0., 1., 0.);
 
121
    v[3] = ccdPtAddVertexCoords(&pt, 0., 1., 0.);
 
122
    assertTrue(ccdVec3Eq(&u, &v[3]->v.v));
 
123
 
 
124
    for (i = 0; i < 4; i++){
 
125
        assertTrue(ccdEq(v[i]->dist, ccdVec3Len2(&v[i]->v.v)));
 
126
    }
 
127
    for (i = 0; i < 4; i++){
 
128
        DBG("v[%d]->dist: %lf", i, v[i]->dist);
 
129
        DBG_VEC3(&v[i]->witness, "     ->witness: ");
 
130
    }
 
131
 
 
132
    e[0] = ccdPtAddEdge(&pt, v[0], v[1]);
 
133
    e[1] = ccdPtAddEdge(&pt, v[1], v[2]);
 
134
    e[2] = ccdPtAddEdge(&pt, v[2], v[0]);
 
135
    e[3] = ccdPtAddEdge(&pt, v[3], v[0]);
 
136
    e[4] = ccdPtAddEdge(&pt, v[3], v[1]);
 
137
    e[5] = ccdPtAddEdge(&pt, v[3], v[2]);
 
138
    for (i = 0; i < 6; i++){
 
139
        DBG("e[%d]->dist: %lf", i, e[i]->dist);
 
140
        DBG_VEC3(&e[i]->witness, "     ->witness: ");
 
141
    }
 
142
 
 
143
    f[0] = ccdPtAddFace(&pt, e[0], e[1], e[2]);
 
144
    f[1] = ccdPtAddFace(&pt, e[3], e[4], e[0]);
 
145
    f[2] = ccdPtAddFace(&pt, e[4], e[5], e[1]);
 
146
    f[3] = ccdPtAddFace(&pt, e[5], e[3], e[2]);
 
147
    for (i = 0; i < 4; i++){
 
148
        DBG("f[%d]->dist: %lf", i, f[i]->dist);
 
149
        DBG_VEC3(&f[i]->witness, "     ->witness: ");
 
150
    }
 
151
 
 
152
    for (i = 0; i < 4; i++){
 
153
        res = ccdPtDelVertex(&pt, v[i]);
 
154
        assertFalse(res == 0);
 
155
    }
 
156
    for (i = 0; i < 6; i++){
 
157
        res = ccdPtDelEdge(&pt, e[i]);
 
158
        assertFalse(res == 0);
 
159
    }
 
160
 
 
161
    res = ccdPtDelFace(&pt, f[0]);
 
162
    for (i = 0; i < 6; i++){
 
163
        res = ccdPtDelEdge(&pt, e[i]);
 
164
        assertFalse(res == 0);
 
165
    }
 
166
 
 
167
    res = ccdPtDelFace(&pt, f[1]);
 
168
    assertTrue(ccdPtDelEdge(&pt, e[0]) == 0);
 
169
    assertFalse(ccdPtDelEdge(&pt, e[1]) == 0);
 
170
    assertFalse(ccdPtDelEdge(&pt, e[2]) == 0);
 
171
    assertFalse(ccdPtDelEdge(&pt, e[3]) == 0);
 
172
    assertFalse(ccdPtDelEdge(&pt, e[4]) == 0);
 
173
    assertFalse(ccdPtDelEdge(&pt, e[5]) == 0);
 
174
    for (i = 0; i < 4; i++){
 
175
        res = ccdPtDelVertex(&pt, v[i]);
 
176
        assertFalse(res == 0);
 
177
    }
 
178
 
 
179
    res = ccdPtDelFace(&pt, f[2]);
 
180
    assertTrue(ccdPtDelEdge(&pt, e[1]) == 0);
 
181
    assertTrue(ccdPtDelEdge(&pt, e[4]) == 0);
 
182
    assertFalse(ccdPtDelEdge(&pt, e[2]) == 0);
 
183
    assertFalse(ccdPtDelEdge(&pt, e[3]) == 0);
 
184
    assertFalse(ccdPtDelEdge(&pt, e[5]) == 0);
 
185
 
 
186
    assertTrue(ccdPtDelVertex(&pt, v[1]) == 0);
 
187
    assertFalse(ccdPtDelVertex(&pt, v[0]) == 0);
 
188
    assertFalse(ccdPtDelVertex(&pt, v[2]) == 0);
 
189
    assertFalse(ccdPtDelVertex(&pt, v[3]) == 0);
 
190
 
 
191
    res = ccdPtDelFace(&pt, f[3]);
 
192
    assertTrue(ccdPtDelEdge(&pt, e[2]) == 0);
 
193
    assertTrue(ccdPtDelEdge(&pt, e[3]) == 0);
 
194
    assertTrue(ccdPtDelEdge(&pt, e[5]) == 0);
 
195
 
 
196
    assertTrue(ccdPtDelVertex(&pt, v[0]) == 0);
 
197
    assertTrue(ccdPtDelVertex(&pt, v[2]) == 0);
 
198
    assertTrue(ccdPtDelVertex(&pt, v[3]) == 0);
 
199
 
 
200
 
 
201
    v[0] = ccdPtAddVertexCoords(&pt, -1., -1., 0.);
 
202
    v[1] = ccdPtAddVertexCoords(&pt, 1., 0., 0.);
 
203
    v[2] = ccdPtAddVertexCoords(&pt, 0., 0., 1.);
 
204
    v[3] = ccdPtAddVertexCoords(&pt, 0., 1., 0.);
 
205
 
 
206
    e[0] = ccdPtAddEdge(&pt, v[0], v[1]);
 
207
    e[1] = ccdPtAddEdge(&pt, v[1], v[2]);
 
208
    e[2] = ccdPtAddEdge(&pt, v[2], v[0]);
 
209
    e[3] = ccdPtAddEdge(&pt, v[3], v[0]);
 
210
    e[4] = ccdPtAddEdge(&pt, v[3], v[1]);
 
211
    e[5] = ccdPtAddEdge(&pt, v[3], v[2]);
 
212
 
 
213
    f[0] = ccdPtAddFace(&pt, e[0], e[1], e[2]);
 
214
    f[1] = ccdPtAddFace(&pt, e[3], e[4], e[0]);
 
215
    f[2] = ccdPtAddFace(&pt, e[4], e[5], e[1]);
 
216
    f[3] = ccdPtAddFace(&pt, e[5], e[3], e[2]);
 
217
 
 
218
    ccdPtDestroy(&pt);
 
219
}
 
220
 
 
221
TEST(ptNearest)
 
222
{
 
223
    ccd_pt_t pt;
 
224
    ccd_pt_vertex_t *v[4];
 
225
    ccd_pt_edge_t *e[6];
 
226
    ccd_pt_face_t *f[4];
 
227
    ccd_pt_el_t *nearest;
 
228
 
 
229
    DBG2("------");
 
230
 
 
231
    ccdPtInit(&pt);
 
232
 
 
233
    v[0] = ccdPtAddVertexCoords(&pt, -1., -1., 0.);
 
234
    v[1] = ccdPtAddVertexCoords(&pt, 1., 0., 0.);
 
235
    v[2] = ccdPtAddVertexCoords(&pt, 0., 0., 1.);
 
236
    v[3] = ccdPtAddVertexCoords(&pt, 0., 1., 0.);
 
237
 
 
238
    e[0] = ccdPtAddEdge(&pt, v[0], v[1]);
 
239
    e[1] = ccdPtAddEdge(&pt, v[1], v[2]);
 
240
    e[2] = ccdPtAddEdge(&pt, v[2], v[0]);
 
241
    e[3] = ccdPtAddEdge(&pt, v[3], v[0]);
 
242
    e[4] = ccdPtAddEdge(&pt, v[3], v[1]);
 
243
    e[5] = ccdPtAddEdge(&pt, v[3], v[2]);
 
244
 
 
245
    f[0] = ccdPtAddFace(&pt, e[0], e[1], e[2]);
 
246
    f[1] = ccdPtAddFace(&pt, e[3], e[4], e[0]);
 
247
    f[2] = ccdPtAddFace(&pt, e[4], e[5], e[1]);
 
248
    f[3] = ccdPtAddFace(&pt, e[5], e[3], e[2]);
 
249
 
 
250
    nearest = ccdPtNearest(&pt);
 
251
    //DBG("nearest->type: %d", nearest->type);
 
252
    //DBG("       ->dist: %lf", nearest->dist);
 
253
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
254
    assertEquals(nearest->type, CCD_PT_FACE);
 
255
    assertEquals(nearest, (ccd_pt_el_t *)f[1]);
 
256
    assertTrue(ccdPtDelFace(&pt, f[1]) == 0);
 
257
 
 
258
 
 
259
    nearest = ccdPtNearest(&pt);
 
260
    //DBG("nearest->type: %d", nearest->type);
 
261
    //DBG("       ->dist: %lf", nearest->dist);
 
262
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
263
    assertEquals(nearest->type, CCD_PT_FACE);
 
264
    assertTrue(nearest == (ccd_pt_el_t *)f[0]
 
265
                || nearest == (ccd_pt_el_t *)f[3]);
 
266
    assertTrue(ccdPtDelFace(&pt, (ccd_pt_face_t *)nearest) == 0);
 
267
 
 
268
 
 
269
    nearest = ccdPtNearest(&pt);
 
270
    //DBG("nearest->type: %d", nearest->type);
 
271
    //DBG("       ->dist: %lf", nearest->dist);
 
272
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
273
    assertEquals(nearest->type, CCD_PT_FACE);
 
274
    assertTrue(nearest == (ccd_pt_el_t *)f[0]
 
275
                || nearest == (ccd_pt_el_t *)f[3]);
 
276
    assertTrue(ccdPtDelFace(&pt, (ccd_pt_face_t *)nearest) == 0);
 
277
 
 
278
 
 
279
    nearest = ccdPtNearest(&pt);
 
280
    //DBG("nearest->type: %d", nearest->type);
 
281
    //DBG("       ->dist: %lf", nearest->dist);
 
282
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
283
    assertEquals(nearest->type, CCD_PT_EDGE);
 
284
    assertTrue(nearest == (ccd_pt_el_t *)e[0]
 
285
                || nearest == (ccd_pt_el_t *)e[3]);
 
286
    assertTrue(ccdPtDelEdge(&pt, (ccd_pt_edge_t *)nearest) == 0);
 
287
 
 
288
 
 
289
    nearest = ccdPtNearest(&pt);
 
290
    //DBG("nearest->type: %d", nearest->type);
 
291
    //DBG("       ->dist: %lf", nearest->dist);
 
292
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
293
    assertEquals(nearest->type, CCD_PT_EDGE);
 
294
    assertTrue(nearest == (ccd_pt_el_t *)e[0]
 
295
                || nearest == (ccd_pt_el_t *)e[3]);
 
296
    assertTrue(ccdPtDelEdge(&pt, (ccd_pt_edge_t *)nearest) == 0);
 
297
 
 
298
 
 
299
    nearest = ccdPtNearest(&pt);
 
300
    //DBG("nearest->type: %d", nearest->type);
 
301
    //DBG("       ->dist: %lf", nearest->dist);
 
302
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
303
    assertEquals(nearest->type, CCD_PT_FACE);
 
304
    assertEquals(nearest, (ccd_pt_el_t *)f[2]);
 
305
    assertTrue(ccdPtDelFace(&pt, f[2]) == 0);
 
306
 
 
307
 
 
308
    nearest = ccdPtNearest(&pt);
 
309
    //DBG("nearest->type: %d", nearest->type);
 
310
    //DBG("       ->dist: %lf", nearest->dist);
 
311
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
312
    assertEquals(nearest->type, CCD_PT_EDGE);
 
313
    assertTrue(nearest == (ccd_pt_el_t *)e[1]
 
314
                || nearest == (ccd_pt_el_t *)e[4]
 
315
                || nearest == (ccd_pt_el_t *)e[5]);
 
316
    assertTrue(ccdPtDelEdge(&pt, (ccd_pt_edge_t *)nearest) == 0);
 
317
 
 
318
 
 
319
    nearest = ccdPtNearest(&pt);
 
320
    //DBG("nearest->type: %d", nearest->type);
 
321
    //DBG("       ->dist: %lf", nearest->dist);
 
322
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
323
    assertEquals(nearest->type, CCD_PT_EDGE);
 
324
    assertTrue(nearest == (ccd_pt_el_t *)e[1]
 
325
                || nearest == (ccd_pt_el_t *)e[4]
 
326
                || nearest == (ccd_pt_el_t *)e[5]);
 
327
    assertTrue(ccdPtDelEdge(&pt, (ccd_pt_edge_t *)nearest) == 0);
 
328
 
 
329
 
 
330
    nearest = ccdPtNearest(&pt);
 
331
    //DBG("nearest->type: %d", nearest->type);
 
332
    //DBG("       ->dist: %lf", nearest->dist);
 
333
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
334
    assertEquals(nearest->type, CCD_PT_EDGE);
 
335
    assertTrue(nearest == (ccd_pt_el_t *)e[1]
 
336
                || nearest == (ccd_pt_el_t *)e[4]
 
337
                || nearest == (ccd_pt_el_t *)e[5]);
 
338
    assertTrue(ccdPtDelEdge(&pt, (ccd_pt_edge_t *)nearest) == 0);
 
339
 
 
340
 
 
341
    nearest = ccdPtNearest(&pt);
 
342
    //DBG("nearest->type: %d", nearest->type);
 
343
    //DBG("       ->dist: %lf", nearest->dist);
 
344
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
345
    assertEquals(nearest->type, CCD_PT_EDGE);
 
346
    assertTrue(nearest == (ccd_pt_el_t *)e[2]);
 
347
    assertTrue(ccdPtDelEdge(&pt, (ccd_pt_edge_t *)nearest) == 0);
 
348
 
 
349
 
 
350
    nearest = ccdPtNearest(&pt);
 
351
    //DBG("nearest->type: %d", nearest->type);
 
352
    //DBG("       ->dist: %lf", nearest->dist);
 
353
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
354
    assertEquals(nearest->type, CCD_PT_VERTEX);
 
355
    assertTrue(nearest == (ccd_pt_el_t *)v[1]
 
356
                || nearest == (ccd_pt_el_t *)v[2]
 
357
                || nearest == (ccd_pt_el_t *)v[3]);
 
358
    assertTrue(ccdPtDelVertex(&pt, (ccd_pt_vertex_t *)nearest) == 0);
 
359
 
 
360
 
 
361
    nearest = ccdPtNearest(&pt);
 
362
    //DBG("nearest->type: %d", nearest->type);
 
363
    //DBG("       ->dist: %lf", nearest->dist);
 
364
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
365
    assertEquals(nearest->type, CCD_PT_VERTEX);
 
366
    assertTrue(nearest == (ccd_pt_el_t *)v[1]
 
367
                || nearest == (ccd_pt_el_t *)v[2]
 
368
                || nearest == (ccd_pt_el_t *)v[3]);
 
369
    assertTrue(ccdPtDelVertex(&pt, (ccd_pt_vertex_t *)nearest) == 0);
 
370
 
 
371
 
 
372
    nearest = ccdPtNearest(&pt);
 
373
    //DBG("nearest->type: %d", nearest->type);
 
374
    //DBG("       ->dist: %lf", nearest->dist);
 
375
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
376
    assertEquals(nearest->type, CCD_PT_VERTEX);
 
377
    assertTrue(nearest == (ccd_pt_el_t *)v[1]
 
378
                || nearest == (ccd_pt_el_t *)v[2]
 
379
                || nearest == (ccd_pt_el_t *)v[3]);
 
380
    assertTrue(ccdPtDelVertex(&pt, (ccd_pt_vertex_t *)nearest) == 0);
 
381
 
 
382
 
 
383
    nearest = ccdPtNearest(&pt);
 
384
    //DBG("nearest->type: %d", nearest->type);
 
385
    //DBG("       ->dist: %lf", nearest->dist);
 
386
    //DBG_VEC3(&nearest->witness, "       ->witness: ");
 
387
    assertEquals(nearest->type, CCD_PT_VERTEX);
 
388
    assertTrue(nearest == (ccd_pt_el_t *)v[0]);
 
389
    assertTrue(ccdPtDelVertex(&pt, (ccd_pt_vertex_t *)nearest) == 0);
 
390
 
 
391
 
 
392
    nearest = ccdPtNearest(&pt);
 
393
    assertTrue(nearest == NULL);
 
394
 
 
395
    ccdPtDestroy(&pt);
 
396
}