1 /*****************************************************************************
2 * Copyright (c) 2019 FrontISTR Commons
3 * This software is released under the MIT License, see LICENSE.txt
4 *****************************************************************************/
5
6 #include "hecmw_vis_intersection_find.h"
7
8 #include "hecmw_vis_calc_attr.h"
9
10 /* provide information for rotation of cube */
get_hex_rotation_info(int rot_type,Rotation_info * rot_info)11 int get_hex_rotation_info(int rot_type, Rotation_info *rot_info) {
12 static Rotation_info rotation[24] = {
13 {{0, 1, 2, 3, 4, 5},
14 {0, 1, 2, 3, 4, 5, 6, 7}, /* rotation No.0 */
15 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
16 {0, 1, 2, 3, 4, 5, 6}},
17 {{5, 2, 4, 0, 1, 3},
18 {0, 4, 5, 1, 3, 7, 6, 2}, /* rotation No.1 */
19 {8, 4, 9, 0, 10, 6, 11, 2, 3, 7, 1, 5},
20 {0, 2, 3, 1, 6, 4, 5}},
21 {{3, 4, 1, 5, 2, 0},
22 {0, 3, 7, 4, 1, 2, 6, 5}, /* rotation No.2 */
23 {3, 10, 7, 8, 1, 11, 5, 9, 0, 2, 4, 6},
24 {0, 3, 1, 2, 5, 6, 4}},
25 {{1, 2, 3, 0, 4, 5},
26 {1, 5, 6, 2, 0, 4, 7, 3}, /* rotation No.3 */
27 {9, 5, 11, 1, 8, 7, 10, 3, 0, 4, 2, 6},
28 {1, 3, 0, 2, 5, 4, 6}},
29 {{5, 3, 4, 1, 2, 0},
30 {1, 0, 4, 5, 2, 3, 7, 6}, /* rotation No.4 */
31 {0, 8, 4, 9, 2, 10, 6, 11, 1, 3, 5, 7},
32 {1, 0, 2, 3, 6, 5, 4}},
33 {{0, 4, 2, 5, 3, 1},
34 {1, 2, 3, 0, 5, 6, 7, 4}, /* rotation No.5 */
35 {1, 2, 3, 0, 5, 6, 7, 4, 9, 11, 8, 10},
36 {1, 2, 3, 0, 4, 6, 5}},
37 {{1, 5, 3, 4, 2, 0},
38 {2, 1, 5, 6, 3, 0, 4, 7}, /* rotation No.6 */
39 {1, 9, 5, 11, 3, 8, 7, 10, 2, 0, 6, 4},
40 {2, 1, 3, 0, 5, 6, 4}},
41 {{0, 3, 2, 1, 5, 4},
42 {2, 3, 0, 1, 6, 7, 4, 5}, /* rotation No.7 */
43 {2, 3, 0, 1, 6, 7, 4, 5, 11, 10, 9, 8},
44 {2, 3, 0, 1, 4, 5, 6}},
45 {{4, 2, 5, 0, 3, 1},
46 {2, 6, 7, 3, 1, 5, 4, 0}, /* rotation No.8 */
47 {11, 6, 10, 2, 9, 4, 8, 0, 1, 5, 3, 7},
48 {2, 0, 1, 3, 6, 4, 5}},
49 {{4, 1, 5, 3, 2, 0},
50 {3, 2, 6, 7, 0, 1, 5, 4}, /* rotation No.9 */
51 {2, 11, 6, 10, 0, 9, 4, 8, 3, 1, 7, 5},
52 {3, 2, 0, 1, 6, 5, 4}},
53 {{0, 5, 2, 4, 1, 3},
54 {3, 0, 1, 2, 7, 4, 5, 6}, /* rotation No.10 */
55 {3, 0, 1, 2, 7, 4, 5, 6, 10, 8, 11, 9},
56 {3, 0, 1, 2, 4, 6, 5}},
57 {{3, 2, 1, 0, 5, 4},
58 {3, 7, 4, 0, 2, 6, 5, 1}, /* rotation No.11 */
59 {10, 7, 8, 3, 11, 5, 9, 1, 2, 6, 0, 4},
60 {3, 1, 2, 0, 5, 4, 6}},
61 {{5, 1, 4, 3, 0, 2},
62 {4, 5, 1, 0, 7, 6, 2, 3}, /* rotation No.12 */
63 {4, 9, 0, 8, 6, 11, 2, 10, 7, 5, 3, 1},
64 {2, 3, 1, 0, 6, 5, 4}},
65 {{2, 4, 0, 5, 1, 3},
66 {4, 7, 6, 5, 0, 3, 2, 1}, /* rotation No.13 */
67 {7, 6, 5, 4, 3, 2, 1, 0, 8, 10, 9, 11},
68 {2, 1, 0, 3, 4, 6, 5}},
69 {{3, 0, 1, 2, 4, 5},
70 {4, 0, 3, 7, 5, 1, 2, 6}, /* rotation No.14 */
71 {8, 3, 10, 7, 9, 1, 11, 5, 4, 0, 6, 2},
72 {2, 0, 3, 1, 5, 4, 6}},
73 {{2, 3, 0, 1, 4, 5},
74 {5, 4, 7, 6, 1, 0, 3, 2}, /* rotation No.15 */
75 {4, 7, 6, 5, 0, 3, 2, 1, 9, 8, 11, 10},
76 {3, 2, 1, 0, 4, 5, 6}},
77 {{5, 0, 4, 2, 3, 1},
78 {5, 1, 0, 4, 6, 2, 3, 7}, /* rotation No.16 */
79 {9, 0, 8, 4, 11, 2, 10, 6, 5, 1, 7, 3},
80 {3, 1, 0, 2, 6, 4, 5}},
81 {{1, 4, 3, 5, 0, 2},
82 {5, 6, 2, 1, 4, 7, 3, 0}, /* rotation No.17 */
83 {5, 11, 1, 9, 7, 10, 3, 8, 4, 6, 0, 2},
84 {3, 0, 2, 1, 5, 6, 4}},
85 {{1, 0, 3, 2, 5, 4},
86 {6, 2, 1, 5, 7, 3, 0, 4}, /* rotation No.18 */
87 {11, 1, 9, 5, 10, 3, 8, 7, 6, 2, 4, 0},
88 {0, 2, 1, 3, 5, 4, 6}},
89 {{4, 3, 5, 1, 0, 2},
90 {6, 7, 3, 2, 5, 4, 0, 1}, /* rotation No.19 */
91 {6, 10, 2, 11, 4, 8, 0, 9, 5, 7, 1, 3},
92 {0, 1, 3, 2, 6, 5, 4}},
93 {{2, 5, 0, 4, 3, 1},
94 {6, 5, 4, 7, 2, 1, 0, 3}, /* rotation No.20 */
95 {5, 4, 7, 6, 1, 0, 3, 2, 11, 9, 10, 8},
96 {0, 3, 2, 1, 4, 6, 5}},
97 {{4, 0, 5, 2, 1, 3},
98 {7, 3, 2, 6, 4, 0, 1, 5}, /* rotation No.21 */
99 {10, 2, 11, 6, 8, 0, 9, 4, 7, 3, 5, 1},
100 {1, 3, 2, 0, 6, 4, 5}},
101 {{3, 5, 1, 4, 0, 2},
102 {7, 4, 0, 3, 6, 5, 1, 2}, /* rotation No.22 */
103 {7, 8, 3, 10, 5, 9, 1, 11, 6, 4, 2, 0},
104 {1, 2, 0, 3, 5, 6, 4}},
105 {{2, 1, 0, 3, 5, 4},
106 {7, 6, 5, 4, 3, 2, 1, 0}, /* rotation No.23 */
107 {6, 5, 4, 7, 2, 1, 0, 3, 10, 11, 8, 9},
108 {1, 0, 3, 2, 4, 5, 6}}};
109
110 *rot_info = rotation[rot_type];
111
112 return 1;
113 }
114
115 /* decide the point location after the rotation */
point_convert(int point_index,Rotation_info * rot_info)116 int point_convert(int point_index, Rotation_info *rot_info) {
117 int converted_index;
118
119 if (point_index < 100) {
120 converted_index = (int)rot_info->edge[point_index];
121 } else if (point_index < 200) {
122 converted_index = 100 + (int)rot_info->inside[point_index - 100];
123 } else {
124 converted_index = 200 + (int)rot_info->grid_point[point_index - 200];
125 }
126
127 return converted_index;
128 }
129
130 /* decide the separation pattern on ambiguous face */
separation_test(struct hecmwST_local_mesh * mesh,Cell * cell,int amb,double fvalue,int CS_type,int disamb_flag)131 int separation_test(struct hecmwST_local_mesh *mesh, Cell *cell, int amb,
132 double fvalue, int CS_type, int disamb_flag) {
133 int sep;
134
135 switch (amb) {
136 case 0:
137 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[0],
138 cell->s_data[1], cell->s_data[2],
139 cell->s_data[3]);
140 break;
141 case 1:
142 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[1],
143 cell->s_data[2], cell->s_data[3],
144 cell->s_data[0]);
145 break;
146 case 2:
147 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[1],
148 cell->s_data[5], cell->s_data[6],
149 cell->s_data[2]);
150 break;
151 case 3:
152 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[5],
153 cell->s_data[6], cell->s_data[2],
154 cell->s_data[1]);
155 break;
156 case 4:
157 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[5],
158 cell->s_data[4], cell->s_data[7],
159 cell->s_data[6]);
160 break;
161 case 5:
162 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[4],
163 cell->s_data[7], cell->s_data[6],
164 cell->s_data[5]);
165 break;
166 case 6:
167 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[4],
168 cell->s_data[0], cell->s_data[3],
169 cell->s_data[7]);
170 break;
171 case 7:
172 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[0],
173 cell->s_data[3], cell->s_data[7],
174 cell->s_data[4]);
175 break;
176 case 8:
177 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[3],
178 cell->s_data[2], cell->s_data[6],
179 cell->s_data[7]);
180 break;
181 case 9:
182 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[2],
183 cell->s_data[6], cell->s_data[7],
184 cell->s_data[3]);
185 break;
186 case 10:
187 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[4],
188 cell->s_data[5], cell->s_data[1],
189 cell->s_data[0]);
190 break;
191 case 11:
192 sep = choice_disambiguation(disamb_flag, fvalue, CS_type, cell->s_data[5],
193 cell->s_data[1], cell->s_data[0],
194 cell->s_data[4]);
195 break;
196 }
197
198 return sep;
199 }
200
201 /* make the boundary polygons of (alpha || beta) interval volume in cube */
case0opp_tiler_hex(Cube_polygons * cube_polys)202 void case0opp_tiler_hex(Cube_polygons *cube_polys) {
203 int i;
204 static int verts[8] = {200, 201, 202, 203, 204, 205, 206, 207};
205 static int isosurf[1] = {-1};
206 /* static int bounds[6][6] = {{4, 0,1,2,3, -1},{4, 1,5,6,2, -1},
207 {4, 5,4,7,6, -1},{4, 4,0,3,7, -1},
208 {4, 3,2,6,7, -1},{4, 4,5,1,0, -1}};
209 */
210
211 cube_polys->verts_num = 8;
212 for (i = 0; i < 8; i++) cube_polys->verts[i] = verts[i];
213
214 *cube_polys->isosurf = isosurf;
215 /* for (i = 0; i < 6; i++) {
216 *cube_polys->bounds[i] = bounds[i];
217 }
218 */
219 }
220
case1_tiler_hex(int index,Cube_polygons * cube_polys)221 void case1_tiler_hex(int index, Cube_polygons *cube_polys) {
222 int i;
223 Rotation_info rot_info;
224 static int verts[4] = {0, 3, 8, 200};
225 static int isosurf[4] = {0, 2, 1, -1};
226 /* static int bounds[6][5] = {{3, 3,0,1, -1},{-1, -1,-1,-1,-1},
227 {-1, -1,-1,-1,-1},{3, 3,1,2, -1},
228 {-1, -1,-1,-1,-1},{3, 3,2,0, -1}};
229 */
230 switch (index) {
231 case 1:
232 get_hex_rotation_info(0, &rot_info);
233 break;
234 case 2:
235 get_hex_rotation_info(3, &rot_info);
236 break;
237 case 4:
238 get_hex_rotation_info(6, &rot_info);
239 break;
240 case 8:
241 get_hex_rotation_info(9, &rot_info);
242 break;
243 case 16:
244 get_hex_rotation_info(12, &rot_info);
245 break;
246 case 32:
247 get_hex_rotation_info(15, &rot_info);
248 break;
249 case 64:
250 get_hex_rotation_info(18, &rot_info);
251 break;
252 case 128:
253 get_hex_rotation_info(21, &rot_info);
254 break;
255 }
256
257 cube_polys->verts_num = 4;
258 for (i = 0; i < 4; i++) {
259 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
260 }
261
262 *cube_polys->isosurf = isosurf;
263 /* for (i = 0; i < 6; i++) {
264 *cube_polys->bounds[rot_info.face[i]] = bounds[i];
265 }
266 */
267 }
268
case1opp_tiler_hex(int index,Cube_polygons * cube_polys)269 void case1opp_tiler_hex(int index, Cube_polygons *cube_polys) {
270 int i;
271 Rotation_info rot_info;
272 static int verts[10] = {0, 3, 8, 201, 202, 203, 204, 205, 206, 207};
273 static int isosurf[4] = {0, 1, 2, -1};
274 /* static int bounds[6][7] = {{5, 0,3,4,5,1, -1},{4, 3,7,8,4, -1,-1},
275 {4, 7,6,9,8, -1,-1},{5, 1,5,9,6,2, -1},
276 {4, 5,4,8,9, -1,-1},{5, 2,6,7,3,0, -1}};
277 */
278 switch (index) {
279 case 254:
280 get_hex_rotation_info(0, &rot_info);
281 break;
282 case 253:
283 get_hex_rotation_info(3, &rot_info);
284 break;
285 case 251:
286 get_hex_rotation_info(6, &rot_info);
287 break;
288 case 247:
289 get_hex_rotation_info(9, &rot_info);
290 break;
291 case 239:
292 get_hex_rotation_info(12, &rot_info);
293 break;
294 case 223:
295 get_hex_rotation_info(15, &rot_info);
296 break;
297 case 191:
298 get_hex_rotation_info(18, &rot_info);
299 break;
300 case 127:
301 get_hex_rotation_info(21, &rot_info);
302 break;
303 }
304
305 cube_polys->verts_num = 10;
306 for (i = 0; i < 10; i++) {
307 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
308 }
309
310 *cube_polys->isosurf = isosurf;
311 /* for (i = 0; i < 6; i++) {
312 *cube_polys->bounds[rot_info.face[i]] = bounds[i];
313 }
314 */
315 }
316
case2_tiler_hex(int index,Cube_polygons * cube_polys)317 void case2_tiler_hex(int index, Cube_polygons *cube_polys) {
318 int i;
319 Rotation_info rot_info;
320 static int verts[6] = {1, 3, 8, 9, 200, 201};
321 static int isosurf[7] = {1, 0, 2, 3, 2, 0, -1};
322 /* static int bounds[6][6] = {{4, 4,5,0,1, -1},{3, 5,3,0, -1,-1},
323 {-1, -1,-1,-1,-1,-1},{3, 4,1,2, -1,-1},
324 {-1, -1,-1,-1,-1,-1},{4, 4,2,3,5, -1}};
325 */
326 switch (index) {
327 case 3:
328 get_hex_rotation_info(0, &rot_info);
329 break;
330 case 6:
331 get_hex_rotation_info(5, &rot_info);
332 break;
333 case 9:
334 get_hex_rotation_info(2, &rot_info);
335 break;
336 case 12:
337 get_hex_rotation_info(7, &rot_info);
338 break;
339 case 17:
340 get_hex_rotation_info(1, &rot_info);
341 break;
342 case 34:
343 get_hex_rotation_info(3, &rot_info);
344 break;
345 case 48:
346 get_hex_rotation_info(12, &rot_info);
347 break;
348 case 68:
349 get_hex_rotation_info(8, &rot_info);
350 break;
351 case 96:
352 get_hex_rotation_info(17, &rot_info);
353 break;
354 case 136:
355 get_hex_rotation_info(11, &rot_info);
356 break;
357 case 144:
358 get_hex_rotation_info(13, &rot_info);
359 break;
360 case 192:
361 get_hex_rotation_info(19, &rot_info);
362 break;
363 }
364
365 cube_polys->verts_num = 6;
366 for (i = 0; i < 6; i++) {
367 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
368 }
369
370 *cube_polys->isosurf = isosurf;
371 /* for (i = 0; i < 6; i++) {
372 *cube_polys->bounds[rot_info.face[i]] = bounds[i];
373 }
374 */
375 }
376
case2opp_tiler_hex(int index,Cube_polygons * cube_polys)377 void case2opp_tiler_hex(int index, Cube_polygons *cube_polys) {
378 int i;
379 Rotation_info rot_info;
380 static int verts[10] = {1, 3, 8, 9, 202, 203, 204, 205, 206, 207};
381 static int isosurf[7] = {0, 1, 2, 2, 3, 0, -1};
382 /* static int bounds[6][7] = {{4, 5,1,0,4, -1,-1},{5, 4,0,3,7,8, -1},
383 {4, 7,6,9,8, -1,-1},{5, 1,5,9,6,2, -1},
384 {4, 5,4,8,9, -1,-1},{4, 2,6,7,3, -1,-1}};
385 */
386 switch (index) {
387 case 252:
388 get_hex_rotation_info(0, &rot_info);
389 break;
390 case 249:
391 get_hex_rotation_info(5, &rot_info);
392 break;
393 case 246:
394 get_hex_rotation_info(2, &rot_info);
395 break;
396 case 243:
397 get_hex_rotation_info(7, &rot_info);
398 break;
399 case 238:
400 get_hex_rotation_info(1, &rot_info);
401 break;
402 case 221:
403 get_hex_rotation_info(3, &rot_info);
404 break;
405 case 207:
406 get_hex_rotation_info(12, &rot_info);
407 break;
408 case 187:
409 get_hex_rotation_info(8, &rot_info);
410 break;
411 case 159:
412 get_hex_rotation_info(17, &rot_info);
413 break;
414 case 119:
415 get_hex_rotation_info(11, &rot_info);
416 break;
417 case 111:
418 get_hex_rotation_info(13, &rot_info);
419 break;
420 case 63:
421 get_hex_rotation_info(19, &rot_info);
422 break;
423 }
424
425 cube_polys->verts_num = 10;
426 for (i = 0; i < 10; i++) {
427 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
428 }
429
430 *cube_polys->isosurf = isosurf;
431 /* for (i = 0; i < 6; i++) {
432 *cube_polys->bounds[rot_info.face[i]] = bounds[i];
433 }
434 */
435 }
436
case3_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)437 void case3_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell, double fvalue,
438 int CS_type, int index, Cube_polygons *cube_polys,
439 int disamb_flag) {
440 int i;
441 int amb_index;
442 Rotation_info rot_info;
443 static int verts[8] = {0, 1, 2, 3, 8, 11, 200, 202};
444 static int isosurf_A[7] = {0, 4, 3, 2, 5, 1, -1};
445 static int isosurf_B[13] = {3, 2, 4, 2, 5, 4, 4, 5, 1, 4, 1, 0, -1};
446 /* static int bounds_0[2][9] = {{3, 6,0,3, 3, 7,2,1, -1},
447 {6, 6,0,1,7,2,3, -1,-1}};
448 static int bounds_1[5] = {3, 7,1,5, -1};
449 static int bounds_2[1] = {-1};
450 static int bounds_3[5] = {3, 6,3,4, -1};
451 static int bounds_4[5] = {3, 7,5,2, -1};
452 static int bounds_5[5] = {3, 6,4,0, -1};
453 */
454 if (disamb_flag == 0) { /* disambiguation : none */
455 amb_index = 0; /* isosurf_A */
456 switch (index) {
457 case 5:
458 get_hex_rotation_info(0, &rot_info);
459 break;
460 case 10:
461 get_hex_rotation_info(10, &rot_info);
462 break;
463 case 18:
464 get_hex_rotation_info(4, &rot_info);
465 break;
466 case 24:
467 get_hex_rotation_info(11, &rot_info);
468 break;
469 case 33:
470 get_hex_rotation_info(1, &rot_info);
471 break;
472 case 36:
473 get_hex_rotation_info(6, &rot_info);
474 break;
475 case 66:
476 get_hex_rotation_info(18, &rot_info);
477 break;
478 case 72:
479 get_hex_rotation_info(9, &rot_info);
480 break;
481 case 80:
482 get_hex_rotation_info(13, &rot_info);
483 break;
484 case 129:
485 get_hex_rotation_info(22, &rot_info);
486 break;
487 case 132:
488 get_hex_rotation_info(21, &rot_info);
489 break;
490 case 160:
491 get_hex_rotation_info(15, &rot_info);
492 break;
493 }
494 } else {
495 switch (index) {
496 case 5:
497 amb_index =
498 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
499 get_hex_rotation_info(0, &rot_info);
500 break;
501 case 10:
502 amb_index =
503 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
504 get_hex_rotation_info(10, &rot_info);
505 break;
506 case 18:
507 amb_index =
508 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
509 get_hex_rotation_info(4, &rot_info);
510 break;
511 case 24:
512 amb_index =
513 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
514 get_hex_rotation_info(11, &rot_info);
515 break;
516 case 33:
517 amb_index =
518 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
519 get_hex_rotation_info(1, &rot_info);
520 break;
521 case 36:
522 amb_index =
523 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
524 get_hex_rotation_info(6, &rot_info);
525 break;
526 case 66:
527 amb_index =
528 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
529 get_hex_rotation_info(18, &rot_info);
530 break;
531 case 72:
532 amb_index =
533 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
534 get_hex_rotation_info(9, &rot_info);
535 break;
536 case 80:
537 amb_index =
538 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
539 get_hex_rotation_info(13, &rot_info);
540 break;
541 case 129:
542 amb_index =
543 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
544 get_hex_rotation_info(22, &rot_info);
545 break;
546 case 132:
547 amb_index =
548 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
549 get_hex_rotation_info(21, &rot_info);
550 break;
551 case 160:
552 amb_index =
553 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
554 get_hex_rotation_info(15, &rot_info);
555 break;
556 }
557 }
558
559 cube_polys->verts_num = 8;
560 for (i = 0; i < 8; i++) {
561 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
562 }
563
564 if (!amb_index) {
565 *cube_polys->isosurf = isosurf_A;
566 /* *cube_polys->bounds[rot_info.face[0]] = bounds_0[0];*/
567 } else {
568 *cube_polys->isosurf = isosurf_B;
569 /* *cube_polys->bounds[rot_info.face[0]] = bounds_0[1];*/
570 }
571
572 /* *cube_polys->bounds[rot_info.face[1]] = bounds_1;
573 *cube_polys->bounds[rot_info.face[2]] = bounds_2;
574 *cube_polys->bounds[rot_info.face[3]] = bounds_3;
575 *cube_polys->bounds[rot_info.face[4]] = bounds_4;
576 *cube_polys->bounds[rot_info.face[5]] = bounds_5;
577 */
578 }
579
case3opp_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)580 void case3opp_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
581 double fvalue, int CS_type, int index,
582 Cube_polygons *cube_polys, int disamb_flag) {
583 int i;
584 int amb_index;
585 Rotation_info rot_info;
586 static int verts[12] = {0, 1, 2, 3, 8, 11, 201, 203, 204, 205, 206, 207};
587 static int isosurf_A[7] = {0, 3, 4, 2, 1, 5, -1};
588 static int isosurf_B[13] = {3, 4, 2, 2, 4, 5, 4, 1, 5, 4, 0, 1, -1};
589 /* static int bounds_0[2][9] = {{6, 7,3,0,6,1,2, -1,-1},
590 {3, 6,1,0, 3, 7,3,2, -1}};
591 static int bounds_1[7] = {5, 6,9,10,5,1, -1};
592 static int bounds_2[6] = {4, 9,8,11,10, -1};
593 static int bounds_3[7] = {5, 7,11,8,4,3, -1};
594 static int bounds_4[7] = {5, 10,11,7,2,5, -1};
595 static int bounds_5[7] = {5, 8,9,6,0,4, -1};
596 */
597 if (disamb_flag == 0) { /* disambiguation : none */
598 amb_index = 0; /* isosurf_A */
599 switch (index) {
600 case 250:
601 get_hex_rotation_info(0, &rot_info);
602 break;
603 case 245:
604 get_hex_rotation_info(10, &rot_info);
605 break;
606 case 237:
607 get_hex_rotation_info(4, &rot_info);
608 break;
609 case 231:
610 get_hex_rotation_info(11, &rot_info);
611 break;
612 case 222:
613 get_hex_rotation_info(1, &rot_info);
614 break;
615 case 219:
616 get_hex_rotation_info(6, &rot_info);
617 break;
618 case 189:
619 get_hex_rotation_info(18, &rot_info);
620 break;
621 case 183:
622 get_hex_rotation_info(9, &rot_info);
623 break;
624 case 175:
625 get_hex_rotation_info(13, &rot_info);
626 break;
627 case 126:
628 get_hex_rotation_info(22, &rot_info);
629 break;
630 case 123:
631 get_hex_rotation_info(21, &rot_info);
632 break;
633 case 95:
634 get_hex_rotation_info(15, &rot_info);
635 break;
636 }
637 } else {
638 switch (index) {
639 case 250:
640 amb_index =
641 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
642 get_hex_rotation_info(0, &rot_info);
643 break;
644 case 245:
645 amb_index =
646 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
647 get_hex_rotation_info(10, &rot_info);
648 break;
649 case 237:
650 amb_index =
651 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
652 get_hex_rotation_info(4, &rot_info);
653 break;
654 case 231:
655 amb_index =
656 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
657 get_hex_rotation_info(11, &rot_info);
658 break;
659 case 222:
660 amb_index =
661 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
662 get_hex_rotation_info(1, &rot_info);
663 break;
664 case 219:
665 amb_index =
666 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
667 get_hex_rotation_info(6, &rot_info);
668 break;
669 case 189:
670 amb_index =
671 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
672 get_hex_rotation_info(18, &rot_info);
673 break;
674 case 183:
675 amb_index =
676 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
677 get_hex_rotation_info(9, &rot_info);
678 break;
679 case 175:
680 amb_index =
681 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
682 get_hex_rotation_info(13, &rot_info);
683 break;
684 case 126:
685 amb_index =
686 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
687 get_hex_rotation_info(22, &rot_info);
688 break;
689 case 123:
690 amb_index =
691 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
692 get_hex_rotation_info(21, &rot_info);
693 break;
694 case 95:
695 amb_index =
696 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
697 get_hex_rotation_info(15, &rot_info);
698 break;
699 }
700 }
701
702 cube_polys->verts_num = 12;
703 for (i = 0; i < 12; i++) {
704 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
705 }
706
707 if (!amb_index) {
708 *cube_polys->isosurf = isosurf_A;
709 /* *cube_polys->bounds[rot_info.face[0]] = bounds_0[0];*/
710 } else {
711 *cube_polys->isosurf = isosurf_B;
712 /* *cube_polys->bounds[rot_info.face[0]] = bounds_0[1];*/
713 }
714
715 /* *cube_polys->bounds[rot_info.face[1]] = bounds_1;
716 *cube_polys->bounds[rot_info.face[2]] = bounds_2;
717 *cube_polys->bounds[rot_info.face[3]] = bounds_3;
718 *cube_polys->bounds[rot_info.face[4]] = bounds_4;
719 *cube_polys->bounds[rot_info.face[5]] = bounds_5;
720 */
721 }
722
case4_tiler_hex(int index,Cube_polygons * cube_polys)723 void case4_tiler_hex(int index, Cube_polygons *cube_polys) {
724 int i;
725 Rotation_info rot_info;
726 static int verts[8] = {0, 3, 5, 6, 8, 11, 200, 206};
727 static int isosurf[7] = {0, 4, 1, 5, 3, 2, -1};
728 /* static int bounds[6][5] = {{3, 6,0,1, -1},{3, 7,5,2, -1},
729 {3, 7,2,3, -1},{3, 6,1,4, -1},
730 {3, 7,3,5, -1},{3, 6,4,0, -1}};
731 */
732 switch (index) {
733 case 20:
734 get_hex_rotation_info(6, &rot_info);
735 break;
736 case 40:
737 get_hex_rotation_info(9, &rot_info);
738 break;
739 case 65:
740 get_hex_rotation_info(0, &rot_info);
741 break;
742 case 130:
743 get_hex_rotation_info(4, &rot_info);
744 break;
745 }
746
747 cube_polys->verts_num = 8;
748 for (i = 0; i < 8; i++) {
749 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
750 }
751
752 *cube_polys->isosurf = isosurf;
753 for (i = 0; i < 6; i++) {
754 /* *cube_polys->bounds[rot_info.face[i]] = bounds[i];*/
755 }
756 }
757
case4opp_tiler_hex(int index,Cube_polygons * cube_polys)758 void case4opp_tiler_hex(int index, Cube_polygons *cube_polys) {
759 int i;
760 Rotation_info rot_info;
761 static int verts[12] = {0, 3, 5, 6, 8, 11, 201, 202, 203, 204, 205, 207};
762 static int isosurf[7] = {0, 1, 4, 5, 2, 3, -1};
763 /* static int bounds[6][7] = {{5, 6,7,8,1,0, -1},{5, 7,6,10,2,5, -1},
764 {5, 10,9,11,3,2, -1},{5, 8,11,9,4,1, -1},
765 {5, 11,8,7,5,3, -1},{5, 9,10,6,0,4, -1}};
766 */
767 switch (index) {
768 case 235:
769 get_hex_rotation_info(6, &rot_info);
770 break;
771 case 215:
772 get_hex_rotation_info(9, &rot_info);
773 break;
774 case 190:
775 get_hex_rotation_info(0, &rot_info);
776 break;
777 case 125:
778 get_hex_rotation_info(4, &rot_info);
779 break;
780 }
781
782 cube_polys->verts_num = 12;
783 for (i = 0; i < 12; i++) {
784 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
785 }
786
787 *cube_polys->isosurf = isosurf;
788 for (i = 0; i < 6; i++) {
789 /* *cube_polys->bounds[rot_info.face[i]] = bounds[i];*/
790 }
791 }
792
case5_tiler_hex(int index,Cube_polygons * cube_polys)793 void case5_tiler_hex(int index, Cube_polygons *cube_polys) {
794 int i;
795 Rotation_info rot_info;
796 static int verts[8] = {0, 1, 5, 7, 8, 201, 204, 205};
797 static int isosurf[10] = {0, 1, 4, 1, 3, 4, 1, 2, 3, -1};
798 /* static int bounds[6][7] = {{3, 5,1,0, -1,-1,-1},{4, 5,7,2,1,
799 -1,-1},
800 {4, 7,6,3,2, -1,-1},{3, 6,4,3, -1,-1,-1},
801 {-1, -1,-1,-1,-1,-1,-1},{5, 6,7,5,0,4, -1}};
802 */
803 if (index < 80) {
804 switch (index) {
805 case 7:
806 get_hex_rotation_info(9, &rot_info);
807 break;
808 case 11:
809 get_hex_rotation_info(6, &rot_info);
810 break;
811 case 13:
812 get_hex_rotation_info(4, &rot_info);
813 break;
814 case 14:
815 get_hex_rotation_info(2, &rot_info);
816 break;
817 case 19:
818 get_hex_rotation_info(15, &rot_info);
819 break;
820 case 25:
821 get_hex_rotation_info(21, &rot_info);
822 break;
823 case 35:
824 get_hex_rotation_info(14, &rot_info);
825 break;
826 case 38:
827 get_hex_rotation_info(20, &rot_info);
828 break;
829 case 49:
830 get_hex_rotation_info(3, &rot_info);
831 break;
832 case 50:
833 get_hex_rotation_info(0, &rot_info);
834 break;
835 case 70:
836 get_hex_rotation_info(16, &rot_info);
837 break;
838 case 76:
839 get_hex_rotation_info(23, &rot_info);
840 break;
841 }
842 } else {
843 switch (index) {
844 case 98:
845 get_hex_rotation_info(8, &rot_info);
846 break;
847 case 100:
848 get_hex_rotation_info(5, &rot_info);
849 break;
850 case 112:
851 get_hex_rotation_info(22, &rot_info);
852 break;
853 case 137:
854 get_hex_rotation_info(13, &rot_info);
855 break;
856 case 140:
857 get_hex_rotation_info(18, &rot_info);
858 break;
859 case 145:
860 get_hex_rotation_info(10, &rot_info);
861 break;
862 case 152:
863 get_hex_rotation_info(1, &rot_info);
864 break;
865 case 176:
866 get_hex_rotation_info(19, &rot_info);
867 break;
868 case 196:
869 get_hex_rotation_info(11, &rot_info);
870 break;
871 case 200:
872 get_hex_rotation_info(7, &rot_info);
873 break;
874 case 208:
875 get_hex_rotation_info(17, &rot_info);
876 break;
877 case 224:
878 get_hex_rotation_info(12, &rot_info);
879 break;
880 }
881 }
882
883 cube_polys->verts_num = 8;
884 for (i = 0; i < 8; i++) {
885 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
886 }
887
888 *cube_polys->isosurf = isosurf;
889 for (i = 0; i < 6; i++) {
890 /* *cube_polys->bounds[rot_info.face[i]] = bounds[i];*/
891 }
892 }
893
case5opp_tiler_hex(int index,Cube_polygons * cube_polys)894 void case5opp_tiler_hex(int index, Cube_polygons *cube_polys) {
895 int i;
896 Rotation_info rot_info;
897 static int verts[10] = {0, 1, 5, 7, 8, 200, 202, 203, 206, 207};
898 static int isosurf[10] = {0, 4, 1, 1, 4, 3, 1, 3, 2, -1};
899 /* static int bounds[6][7] = {{5, 6,7,5,0,1, -1},{4, 8,6,1,2, -1,-1},
900 {4, 9,8,2,3, -1,-1},{5, 5,7,9,3,4, -1},
901 {4, 6,8,9,7, -1,-1},{3, 5,4,0, -1,-1,-1}};
902 */
903 if (index > 170) {
904 switch (index) {
905 case 248:
906 get_hex_rotation_info(9, &rot_info);
907 break;
908 case 244:
909 get_hex_rotation_info(6, &rot_info);
910 break;
911 case 242:
912 get_hex_rotation_info(4, &rot_info);
913 break;
914 case 241:
915 get_hex_rotation_info(2, &rot_info);
916 break;
917 case 236:
918 get_hex_rotation_info(15, &rot_info);
919 break;
920 case 230:
921 get_hex_rotation_info(21, &rot_info);
922 break;
923 case 220:
924 get_hex_rotation_info(14, &rot_info);
925 break;
926 case 217:
927 get_hex_rotation_info(20, &rot_info);
928 break;
929 case 206:
930 get_hex_rotation_info(3, &rot_info);
931 break;
932 case 205:
933 get_hex_rotation_info(0, &rot_info);
934 break;
935 case 185:
936 get_hex_rotation_info(16, &rot_info);
937 break;
938 case 179:
939 get_hex_rotation_info(23, &rot_info);
940 break;
941 }
942 } else {
943 switch (index) {
944 case 157:
945 get_hex_rotation_info(8, &rot_info);
946 break;
947 case 155:
948 get_hex_rotation_info(5, &rot_info);
949 break;
950 case 143:
951 get_hex_rotation_info(22, &rot_info);
952 break;
953 case 118:
954 get_hex_rotation_info(13, &rot_info);
955 break;
956 case 115:
957 get_hex_rotation_info(18, &rot_info);
958 break;
959 case 110:
960 get_hex_rotation_info(10, &rot_info);
961 break;
962 case 103:
963 get_hex_rotation_info(1, &rot_info);
964 break;
965 case 79:
966 get_hex_rotation_info(19, &rot_info);
967 break;
968 case 59:
969 get_hex_rotation_info(11, &rot_info);
970 break;
971 case 55:
972 get_hex_rotation_info(7, &rot_info);
973 break;
974 case 47:
975 get_hex_rotation_info(17, &rot_info);
976 break;
977 case 31:
978 get_hex_rotation_info(12, &rot_info);
979 break;
980 }
981 }
982 cube_polys->verts_num = 10;
983 for (i = 0; i < 10; i++) {
984 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
985 }
986
987 *cube_polys->isosurf = isosurf;
988 for (i = 0; i < 6; i++) {
989 /* *cube_polys->bounds[rot_info.face[i]] = bounds[i];*/
990 }
991 }
992
case6_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)993 void case6_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell, double fvalue,
994 int CS_type, int index, Cube_polygons *cube_polys,
995 int disamb_flag) {
996 int i;
997 int amb_index;
998 Rotation_info rot_info;
999 static int verts[10] = {1, 3, 5, 6, 8, 9, 11, 200, 201, 206};
1000 static int isosurf_A[16] = {0, 6, 1, 1, 6, 3, 1, 3, 4, 4, 3, 2, 4, 2, 5, -1};
1001 static int isosurf_B[10] = {1, 0, 4, 4, 0, 5, 6, 3, 2, -1};
1002 /* static int bounds_0[6] = {4, 7,8,0,1, -1};
1003 static int bounds_1[2][9] = {{6, 8,5,2,9,6,0, -1,-1},
1004 {3, 8,5,0, 3, 9,6,2, -1}};
1005 static int bounds_2[5] = {3, 9,2,3, -1};
1006 static int bounds_3[5] = {3, 7,1,4, -1};
1007 static int bounds_4[5] = {3, 9,3,6, -1};
1008 static int bounds_5[6] = {4, 8,7,4,5, -1};
1009 */
1010 if (disamb_flag == 0) { /* disambiguation : none */
1011 amb_index = 0; /* isosurf_B */
1012 if (index < 82) {
1013 switch (index) {
1014 case 21:
1015 get_hex_rotation_info(14, &rot_info);
1016 break;
1017 case 22:
1018 get_hex_rotation_info(6, &rot_info);
1019 break;
1020 case 28:
1021 get_hex_rotation_info(7, &rot_info);
1022 break;
1023 case 41:
1024 get_hex_rotation_info(10, &rot_info);
1025 break;
1026 case 42:
1027 get_hex_rotation_info(16, &rot_info);
1028 break;
1029 case 44:
1030 get_hex_rotation_info(9, &rot_info);
1031 break;
1032 case 52:
1033 get_hex_rotation_info(12, &rot_info);
1034 break;
1035 case 56:
1036 get_hex_rotation_info(15, &rot_info);
1037 break;
1038 case 67:
1039 get_hex_rotation_info(0, &rot_info);
1040 break;
1041 case 69:
1042 get_hex_rotation_info(18, &rot_info);
1043 break;
1044 case 73:
1045 get_hex_rotation_info(2, &rot_info);
1046 break;
1047 case 81:
1048 get_hex_rotation_info(1, &rot_info);
1049 break;
1050 }
1051 } else {
1052 switch (index) {
1053 case 84:
1054 get_hex_rotation_info(8, &rot_info);
1055 break;
1056 case 97:
1057 get_hex_rotation_info(20, &rot_info);
1058 break;
1059 case 104:
1060 get_hex_rotation_info(17, &rot_info);
1061 break;
1062 case 131:
1063 get_hex_rotation_info(4, &rot_info);
1064 break;
1065 case 134:
1066 get_hex_rotation_info(5, &rot_info);
1067 break;
1068 case 138:
1069 get_hex_rotation_info(21, &rot_info);
1070 break;
1071 case 146:
1072 get_hex_rotation_info(22, &rot_info);
1073 break;
1074 case 148:
1075 get_hex_rotation_info(13, &rot_info);
1076 break;
1077 case 162:
1078 get_hex_rotation_info(3, &rot_info);
1079 break;
1080 case 168:
1081 get_hex_rotation_info(11, &rot_info);
1082 break;
1083 case 193:
1084 get_hex_rotation_info(19, &rot_info);
1085 break;
1086 case 194:
1087 get_hex_rotation_info(23, &rot_info);
1088 break;
1089 }
1090 }
1091 } else {
1092 if (index < 82) {
1093 switch (index) {
1094 case 21:
1095 amb_index =
1096 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1097 get_hex_rotation_info(14, &rot_info);
1098 break;
1099 case 22:
1100 amb_index =
1101 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1102 get_hex_rotation_info(6, &rot_info);
1103 break;
1104 case 28:
1105 amb_index =
1106 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1107 get_hex_rotation_info(7, &rot_info);
1108 break;
1109 case 41:
1110 amb_index =
1111 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1112 get_hex_rotation_info(10, &rot_info);
1113 break;
1114 case 42:
1115 amb_index =
1116 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1117 get_hex_rotation_info(16, &rot_info);
1118 break;
1119 case 44:
1120 amb_index =
1121 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
1122 get_hex_rotation_info(9, &rot_info);
1123 break;
1124 case 52:
1125 amb_index =
1126 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
1127 get_hex_rotation_info(12, &rot_info);
1128 break;
1129 case 56:
1130 amb_index =
1131 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1132 get_hex_rotation_info(15, &rot_info);
1133 break;
1134 case 67:
1135 amb_index =
1136 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1137 get_hex_rotation_info(0, &rot_info);
1138 break;
1139 case 69:
1140 amb_index =
1141 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1142 get_hex_rotation_info(18, &rot_info);
1143 break;
1144 case 73:
1145 amb_index =
1146 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1147 get_hex_rotation_info(2, &rot_info);
1148 break;
1149 case 81:
1150 amb_index =
1151 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1152 get_hex_rotation_info(1, &rot_info);
1153 break;
1154 }
1155 } else {
1156 switch (index) {
1157 case 84:
1158 amb_index =
1159 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1160 get_hex_rotation_info(8, &rot_info);
1161 break;
1162 case 97:
1163 amb_index =
1164 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1165 get_hex_rotation_info(20, &rot_info);
1166 break;
1167 case 104:
1168 amb_index =
1169 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1170 get_hex_rotation_info(17, &rot_info);
1171 break;
1172 case 131:
1173 amb_index =
1174 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1175 get_hex_rotation_info(4, &rot_info);
1176 break;
1177 case 134:
1178 amb_index =
1179 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
1180 get_hex_rotation_info(5, &rot_info);
1181 break;
1182 case 138:
1183 amb_index =
1184 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1185 get_hex_rotation_info(21, &rot_info);
1186 break;
1187 case 146:
1188 amb_index =
1189 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1190 get_hex_rotation_info(22, &rot_info);
1191 break;
1192 case 148:
1193 amb_index =
1194 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
1195 get_hex_rotation_info(13, &rot_info);
1196 break;
1197 case 162:
1198 amb_index =
1199 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
1200 get_hex_rotation_info(3, &rot_info);
1201 break;
1202 case 168:
1203 amb_index =
1204 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
1205 get_hex_rotation_info(11, &rot_info);
1206 break;
1207 case 193:
1208 amb_index =
1209 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1210 get_hex_rotation_info(19, &rot_info);
1211 break;
1212 case 194:
1213 amb_index =
1214 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1215 get_hex_rotation_info(23, &rot_info);
1216 break;
1217 }
1218 }
1219 }
1220
1221 cube_polys->verts_num = 10;
1222 for (i = 0; i < 10; i++) {
1223 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
1224 }
1225
1226 /* *cube_polys->bounds[rot_info.face[0]] = bounds_0;*/
1227
1228 if (amb_index) {
1229 *cube_polys->isosurf = isosurf_A;
1230 /* *cube_polys->bounds[rot_info.face[1]] = bounds_1[0];*/
1231 } else {
1232 *cube_polys->isosurf = isosurf_B;
1233 /* *cube_polys->bounds[rot_info.face[1]] = bounds_1[1];*/
1234 }
1235
1236 /* *cube_polys->bounds[rot_info.face[2]] = bounds_2;
1237 *cube_polys->bounds[rot_info.face[3]] = bounds_3;
1238 *cube_polys->bounds[rot_info.face[4]] = bounds_4;
1239 *cube_polys->bounds[rot_info.face[5]] = bounds_5;
1240 */
1241 }
1242
case6opp_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)1243 void case6opp_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
1244 double fvalue, int CS_type, int index,
1245 Cube_polygons *cube_polys, int disamb_flag) {
1246 int i;
1247 int amb_index;
1248 Rotation_info rot_info;
1249 static int verts[12] = {1, 3, 5, 6, 8, 9, 11, 202, 203, 204, 205, 207};
1250 static int isosurf_A[16] = {0, 1, 6, 1, 3, 6, 1, 4, 3, 4, 2, 3, 4, 5, 2, -1};
1251 static int isosurf_B[10] = {1, 4, 0, 4, 5, 0, 6, 2, 3, -1};
1252 /* static int bounds_0[6] = {4, 7,8,1,0, -1};
1253 static int bounds_1[2][9] = {{3, 7,0,6, 3, 10,2,5, -1},
1254 {6, 7,0,5,10,2,6, -1,-1}};
1255 static int bounds_2[7] = {5, 10,9,11,3,2, -1};
1256 static int bounds_3[7] = {5, 8,11,9,4,1, -1};
1257 static int bounds_4[7] = {5, 11,8,7,6,3, -1};
1258 static int bounds_5[6] = {4, 9,10,5,4, -1};
1259 */
1260 if (disamb_flag == 0) { /* disambiguation : none */
1261 amb_index = 0; /* isosurf_B */
1262 if (index > 173) {
1263 switch (index) {
1264 case 234:
1265 get_hex_rotation_info(14, &rot_info);
1266 break;
1267 case 233:
1268 get_hex_rotation_info(6, &rot_info);
1269 break;
1270 case 227:
1271 get_hex_rotation_info(7, &rot_info);
1272 break;
1273 case 214:
1274 get_hex_rotation_info(10, &rot_info);
1275 break;
1276 case 213:
1277 get_hex_rotation_info(16, &rot_info);
1278 break;
1279 case 211:
1280 get_hex_rotation_info(9, &rot_info);
1281 break;
1282 case 203:
1283 get_hex_rotation_info(12, &rot_info);
1284 break;
1285 case 199:
1286 get_hex_rotation_info(15, &rot_info);
1287 break;
1288 case 188:
1289 get_hex_rotation_info(0, &rot_info);
1290 break;
1291 case 186:
1292 get_hex_rotation_info(18, &rot_info);
1293 break;
1294 case 182:
1295 get_hex_rotation_info(2, &rot_info);
1296 break;
1297 case 174:
1298 get_hex_rotation_info(1, &rot_info);
1299 break;
1300 }
1301 } else {
1302 switch (index) {
1303 case 171:
1304 get_hex_rotation_info(8, &rot_info);
1305 break;
1306 case 158:
1307 get_hex_rotation_info(20, &rot_info);
1308 break;
1309 case 151:
1310 get_hex_rotation_info(17, &rot_info);
1311 break;
1312 case 124:
1313 get_hex_rotation_info(4, &rot_info);
1314 break;
1315 case 121:
1316 get_hex_rotation_info(5, &rot_info);
1317 break;
1318 case 117:
1319 get_hex_rotation_info(21, &rot_info);
1320 break;
1321 case 109:
1322 get_hex_rotation_info(22, &rot_info);
1323 break;
1324 case 107:
1325 get_hex_rotation_info(13, &rot_info);
1326 break;
1327 case 93:
1328 get_hex_rotation_info(3, &rot_info);
1329 break;
1330 case 87:
1331 get_hex_rotation_info(11, &rot_info);
1332 break;
1333 case 62:
1334 get_hex_rotation_info(19, &rot_info);
1335 break;
1336 case 61:
1337 get_hex_rotation_info(23, &rot_info);
1338 break;
1339 }
1340 }
1341 } else {
1342 if (index > 173) {
1343 switch (index) {
1344 case 234:
1345 amb_index =
1346 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1347 get_hex_rotation_info(14, &rot_info);
1348 break;
1349 case 233:
1350 amb_index =
1351 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1352 get_hex_rotation_info(6, &rot_info);
1353 break;
1354 case 227:
1355 amb_index =
1356 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1357 get_hex_rotation_info(7, &rot_info);
1358 break;
1359 case 214:
1360 amb_index =
1361 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1362 get_hex_rotation_info(10, &rot_info);
1363 break;
1364 case 213:
1365 amb_index =
1366 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1367 get_hex_rotation_info(16, &rot_info);
1368 break;
1369 case 211:
1370 amb_index =
1371 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
1372 get_hex_rotation_info(9, &rot_info);
1373 break;
1374 case 203:
1375 amb_index =
1376 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
1377 get_hex_rotation_info(12, &rot_info);
1378 break;
1379 case 199:
1380 amb_index =
1381 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1382 get_hex_rotation_info(15, &rot_info);
1383 break;
1384 case 188:
1385 amb_index =
1386 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1387 get_hex_rotation_info(0, &rot_info);
1388 break;
1389 case 186:
1390 amb_index =
1391 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1392 get_hex_rotation_info(18, &rot_info);
1393 break;
1394 case 182:
1395 amb_index =
1396 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1397 get_hex_rotation_info(2, &rot_info);
1398 break;
1399 case 174:
1400 amb_index =
1401 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1402 get_hex_rotation_info(1, &rot_info);
1403 break;
1404 }
1405 } else {
1406 switch (index) {
1407 case 171:
1408 amb_index =
1409 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1410 get_hex_rotation_info(8, &rot_info);
1411 break;
1412 case 158:
1413 amb_index =
1414 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1415 get_hex_rotation_info(20, &rot_info);
1416 break;
1417 case 151:
1418 amb_index =
1419 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1420 get_hex_rotation_info(17, &rot_info);
1421 break;
1422 case 124:
1423 amb_index =
1424 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1425 get_hex_rotation_info(4, &rot_info);
1426 break;
1427 case 121:
1428 amb_index =
1429 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
1430 get_hex_rotation_info(5, &rot_info);
1431 break;
1432 case 117:
1433 amb_index =
1434 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1435 get_hex_rotation_info(21, &rot_info);
1436 break;
1437 case 109:
1438 amb_index =
1439 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1440 get_hex_rotation_info(22, &rot_info);
1441 break;
1442 case 107:
1443 amb_index =
1444 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
1445 get_hex_rotation_info(13, &rot_info);
1446 break;
1447 case 93:
1448 amb_index =
1449 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
1450 get_hex_rotation_info(3, &rot_info);
1451 break;
1452 case 87:
1453 amb_index =
1454 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
1455 get_hex_rotation_info(11, &rot_info);
1456 break;
1457 case 62:
1458 amb_index =
1459 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1460 get_hex_rotation_info(19, &rot_info);
1461 break;
1462 case 61:
1463 amb_index =
1464 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1465 get_hex_rotation_info(23, &rot_info);
1466 break;
1467 }
1468 }
1469 }
1470
1471 cube_polys->verts_num = 12;
1472 for (i = 0; i < 12; i++) {
1473 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
1474 }
1475
1476 /* *cube_polys->bounds[rot_info.face[0]] = bounds_0;*/
1477
1478 if (amb_index) {
1479 *cube_polys->isosurf = isosurf_A;
1480 /* *cube_polys->bounds[rot_info.face[1]] = bounds_1[0];*/
1481 } else {
1482 *cube_polys->isosurf = isosurf_B;
1483 /* *cube_polys->bounds[rot_info.face[1]] = bounds_1[1];*/
1484 }
1485
1486 /* *cube_polys->bounds[rot_info.face[2]] = bounds_2;
1487 *cube_polys->bounds[rot_info.face[3]] = bounds_3;
1488 *cube_polys->bounds[rot_info.face[4]] = bounds_4;
1489 *cube_polys->bounds[rot_info.face[5]] = bounds_5;
1490 */
1491 }
1492
case7_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)1493 void case7_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell, double fvalue,
1494 int CS_type, int index, Cube_polygons *cube_polys,
1495 int disamb_flag) {
1496 int i;
1497 int amb_index;
1498 Rotation_info rot_info;
1499 static int verts[13] = {0, 1, 2, 3, 5, 6, 9, 10, 11, 201, 203, 206, 101};
1500 static int isosurf_A[10] = {0, 1, 6, 3, 7, 2, 8, 5, 4, -1};
1501 static int isosurf_B[16] = {8, 5, 4, 3, 7, 0, 0, 7, 6, 6, 7, 2, 6, 2, 1, -1};
1502 static int isosurf_C[28] = {6, 0, 12, 0, 3, 12, 3, 7, 12, 7, 2, 12, 2, 1, 12,
1503 1, 8, 12, 8, 5, 12, 5, 4, 12, 4, 6, 12, -1};
1504 static int isosurf_D[16] = {8, 2, 1, 0, 3, 7, 0, 7, 5, 0, 5, 6, 6, 5, 4, -1};
1505
1506 if (disamb_flag == 0) { /* disambiguation : none */
1507 amb_index = 0;
1508 switch (index) {
1509 case 26:
1510 get_hex_rotation_info(16, &rot_info);
1511 break;
1512 case 37:
1513 get_hex_rotation_info(10, &rot_info);
1514 break;
1515 case 74:
1516 get_hex_rotation_info(0, &rot_info);
1517 break;
1518 case 82:
1519 get_hex_rotation_info(6, &rot_info);
1520 break;
1521 case 88:
1522 get_hex_rotation_info(2, &rot_info);
1523 break;
1524 case 133:
1525 get_hex_rotation_info(14, &rot_info);
1526 break;
1527 case 161:
1528 get_hex_rotation_info(4, &rot_info);
1529 break;
1530 case 164:
1531 get_hex_rotation_info(9, &rot_info);
1532 break;
1533 }
1534 } else {
1535 amb_index = 0;
1536 switch (index) {
1537 case 26:
1538 amb_index |=
1539 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1540 amb_index <<= 1;
1541 amb_index |=
1542 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1543 amb_index <<= 1;
1544 amb_index |=
1545 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1546 switch (amb_index) {
1547 case 0:
1548 case 1:
1549 case 3:
1550 case 7:
1551 get_hex_rotation_info(16, &rot_info);
1552 break;
1553 case 2:
1554 case 6:
1555 get_hex_rotation_info(7, &rot_info);
1556 break;
1557 case 4:
1558 case 5:
1559 get_hex_rotation_info(22, &rot_info);
1560 break;
1561 }
1562 break;
1563 case 37:
1564 amb_index |=
1565 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
1566 amb_index <<= 1;
1567 amb_index |=
1568 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1569 amb_index <<= 1;
1570 amb_index |=
1571 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1572 switch (amb_index) {
1573 case 0:
1574 case 1:
1575 case 3:
1576 case 7:
1577 get_hex_rotation_info(10, &rot_info);
1578 break;
1579 case 2:
1580 case 6:
1581 get_hex_rotation_info(12, &rot_info);
1582 break;
1583 case 4:
1584 case 5:
1585 get_hex_rotation_info(18, &rot_info);
1586 break;
1587 }
1588 break;
1589 case 74:
1590 amb_index |=
1591 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1592 amb_index <<= 1;
1593 amb_index |=
1594 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1595 amb_index <<= 1;
1596 amb_index |=
1597 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1598 switch (amb_index) {
1599 case 0:
1600 case 1:
1601 case 3:
1602 case 7:
1603 get_hex_rotation_info(0, &rot_info);
1604 break;
1605 case 2:
1606 case 6:
1607 get_hex_rotation_info(17, &rot_info);
1608 break;
1609 case 4:
1610 case 5:
1611 get_hex_rotation_info(21, &rot_info);
1612 break;
1613 }
1614 break;
1615 case 82:
1616 amb_index |=
1617 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1618 amb_index <<= 1;
1619 amb_index |=
1620 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1621 amb_index <<= 1;
1622 amb_index |=
1623 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1624 switch (amb_index) {
1625 case 0:
1626 case 1:
1627 case 3:
1628 case 7:
1629 get_hex_rotation_info(6, &rot_info);
1630 break;
1631 case 2:
1632 case 6:
1633 get_hex_rotation_info(1, &rot_info);
1634 break;
1635 case 4:
1636 case 5:
1637 get_hex_rotation_info(23, &rot_info);
1638 break;
1639 }
1640 break;
1641 case 88:
1642 amb_index |=
1643 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1644 amb_index <<= 1;
1645 amb_index |=
1646 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1647 amb_index <<= 1;
1648 amb_index |=
1649 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1650 switch (amb_index) {
1651 case 0:
1652 case 1:
1653 case 3:
1654 case 7:
1655 get_hex_rotation_info(2, &rot_info);
1656 break;
1657 case 2:
1658 case 6:
1659 get_hex_rotation_info(8, &rot_info);
1660 break;
1661 case 4:
1662 case 5:
1663 get_hex_rotation_info(15, &rot_info);
1664 break;
1665 }
1666 break;
1667 case 133:
1668 amb_index |=
1669 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
1670 amb_index <<= 1;
1671 amb_index |=
1672 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1673 amb_index <<= 1;
1674 amb_index |=
1675 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1676 switch (amb_index) {
1677 case 0:
1678 case 1:
1679 case 3:
1680 case 7:
1681 get_hex_rotation_info(14, &rot_info);
1682 break;
1683 case 2:
1684 case 6:
1685 get_hex_rotation_info(5, &rot_info);
1686 break;
1687 case 4:
1688 case 5:
1689 get_hex_rotation_info(19, &rot_info);
1690 break;
1691 }
1692 break;
1693 case 161:
1694 amb_index |=
1695 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
1696 amb_index <<= 1;
1697 amb_index |=
1698 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1699 amb_index <<= 1;
1700 amb_index |=
1701 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1702 switch (amb_index) {
1703 case 0:
1704 case 1:
1705 case 3:
1706 case 7:
1707 get_hex_rotation_info(4, &rot_info);
1708 break;
1709 case 2:
1710 case 6:
1711 get_hex_rotation_info(11, &rot_info);
1712 break;
1713 case 4:
1714 case 5:
1715 get_hex_rotation_info(20, &rot_info);
1716 break;
1717 }
1718 break;
1719 case 164:
1720 amb_index |=
1721 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
1722 amb_index <<= 1;
1723 amb_index |=
1724 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
1725 amb_index <<= 1;
1726 amb_index |=
1727 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
1728 switch (amb_index) {
1729 case 0:
1730 case 1:
1731 case 3:
1732 case 7:
1733 get_hex_rotation_info(9, &rot_info);
1734 break;
1735 case 2:
1736 case 6:
1737 get_hex_rotation_info(3, &rot_info);
1738 break;
1739 case 4:
1740 case 5:
1741 get_hex_rotation_info(13, &rot_info);
1742 break;
1743 }
1744 break;
1745 }
1746 }
1747
1748 switch (amb_index) {
1749 case 0:
1750 cube_polys->verts_num = 12;
1751 for (i = 0; i < 12; i++) {
1752 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
1753 }
1754 *cube_polys->isosurf = isosurf_A;
1755
1756 break;
1757 case 1:
1758 case 2:
1759 case 4:
1760 cube_polys->verts_num = 12;
1761 for (i = 0; i < 12; i++) {
1762 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
1763 }
1764 *cube_polys->isosurf = isosurf_B;
1765
1766 break;
1767 case 3:
1768 case 5:
1769 case 6:
1770 cube_polys->verts_num = 13;
1771 for (i = 0; i < 13; i++) {
1772 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
1773 }
1774 *cube_polys->isosurf = isosurf_C;
1775
1776 break;
1777 case 7:
1778 cube_polys->verts_num = 12;
1779 for (i = 0; i < 12; i++) {
1780 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
1781 }
1782 *cube_polys->isosurf = isosurf_D;
1783
1784 break;
1785 }
1786 }
1787
case7opp_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)1788 void case7opp_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
1789 double fvalue, int CS_type, int index,
1790 Cube_polygons *cube_polys, int disamb_flag) {
1791 int i;
1792 int amb_index;
1793 Rotation_info rot_info;
1794 static int verts[15] = {0, 1, 2, 3, 5, 6, 9, 10,
1795 11, 200, 202, 204, 205, 207, 101};
1796 static int isosurf_A[10] = {0, 6, 1, 3, 2, 7, 8, 4, 5, -1};
1797 static int isosurf_B[16] = {8, 4, 5, 3, 0, 7, 0, 6, 7, 6, 2, 7, 6, 1, 2, -1};
1798 static int isosurf_C[28] = {0, 6, 14, 3, 0, 14, 7, 3, 14, 2, 7, 14, 1, 2, 14,
1799 8, 1, 14, 5, 8, 14, 4, 5, 14, 6, 4, 14, -1};
1800 static int isosurf_D[16] = {8, 1, 2, 0, 7, 3, 0, 5, 7, 0, 6, 5, 6, 4, 5, -1};
1801
1802 if (disamb_flag == 0) { /* disambiguation : none */
1803 amb_index = 0;
1804 switch (index) {
1805 case 229:
1806 get_hex_rotation_info(16, &rot_info);
1807 break;
1808 case 218:
1809 get_hex_rotation_info(10, &rot_info);
1810 break;
1811 case 181:
1812 get_hex_rotation_info(0, &rot_info);
1813 break;
1814 case 173:
1815 get_hex_rotation_info(6, &rot_info);
1816 break;
1817 case 167:
1818 get_hex_rotation_info(2, &rot_info);
1819 break;
1820 case 122:
1821 get_hex_rotation_info(14, &rot_info);
1822 break;
1823 case 94:
1824 get_hex_rotation_info(4, &rot_info);
1825 break;
1826 case 91:
1827 get_hex_rotation_info(9, &rot_info);
1828 break;
1829 }
1830 } else {
1831 amb_index = 0;
1832 switch (index) {
1833 case 229:
1834 amb_index |=
1835 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1836 amb_index <<= 1;
1837 amb_index |=
1838 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1839 amb_index <<= 1;
1840 amb_index |=
1841 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1842 switch (amb_index) {
1843 case 0:
1844 case 1:
1845 case 3:
1846 case 7:
1847 get_hex_rotation_info(16, &rot_info);
1848 break;
1849 case 2:
1850 case 6:
1851 get_hex_rotation_info(7, &rot_info);
1852 break;
1853 case 4:
1854 case 5:
1855 get_hex_rotation_info(22, &rot_info);
1856 break;
1857 }
1858 break;
1859 case 218:
1860 amb_index |=
1861 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
1862 amb_index <<= 1;
1863 amb_index |=
1864 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1865 amb_index <<= 1;
1866 amb_index |=
1867 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1868 switch (amb_index) {
1869 case 0:
1870 case 1:
1871 case 3:
1872 case 7:
1873 get_hex_rotation_info(10, &rot_info);
1874 break;
1875 case 2:
1876 case 6:
1877 get_hex_rotation_info(12, &rot_info);
1878 break;
1879 case 4:
1880 case 5:
1881 get_hex_rotation_info(18, &rot_info);
1882 break;
1883 }
1884 break;
1885 case 181:
1886 amb_index |=
1887 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1888 amb_index <<= 1;
1889 amb_index |=
1890 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1891 amb_index <<= 1;
1892 amb_index |=
1893 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
1894 switch (amb_index) {
1895 case 0:
1896 case 1:
1897 case 3:
1898 case 7:
1899 get_hex_rotation_info(0, &rot_info);
1900 break;
1901 case 2:
1902 case 6:
1903 get_hex_rotation_info(17, &rot_info);
1904 break;
1905 case 4:
1906 case 5:
1907 get_hex_rotation_info(21, &rot_info);
1908 break;
1909 }
1910 break;
1911 case 173:
1912 amb_index |=
1913 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1914 amb_index <<= 1;
1915 amb_index |=
1916 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
1917 amb_index <<= 1;
1918 amb_index |=
1919 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
1920 switch (amb_index) {
1921 case 0:
1922 case 1:
1923 case 3:
1924 case 7:
1925 get_hex_rotation_info(6, &rot_info);
1926 break;
1927 case 2:
1928 case 6:
1929 get_hex_rotation_info(1, &rot_info);
1930 break;
1931 case 4:
1932 case 5:
1933 get_hex_rotation_info(23, &rot_info);
1934 break;
1935 }
1936 break;
1937 case 167:
1938 amb_index |=
1939 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
1940 amb_index <<= 1;
1941 amb_index |=
1942 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
1943 amb_index <<= 1;
1944 amb_index |=
1945 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
1946 switch (amb_index) {
1947 case 0:
1948 case 1:
1949 case 3:
1950 case 7:
1951 get_hex_rotation_info(2, &rot_info);
1952 break;
1953 case 2:
1954 case 6:
1955 get_hex_rotation_info(8, &rot_info);
1956 break;
1957 case 4:
1958 case 5:
1959 get_hex_rotation_info(15, &rot_info);
1960 break;
1961 }
1962 break;
1963 case 122:
1964 amb_index |=
1965 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
1966 amb_index <<= 1;
1967 amb_index |=
1968 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
1969 amb_index <<= 1;
1970 amb_index |=
1971 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1972 switch (amb_index) {
1973 case 0:
1974 case 1:
1975 case 3:
1976 case 7:
1977 get_hex_rotation_info(14, &rot_info);
1978 break;
1979 case 2:
1980 case 6:
1981 get_hex_rotation_info(5, &rot_info);
1982 break;
1983 case 4:
1984 case 5:
1985 get_hex_rotation_info(19, &rot_info);
1986 break;
1987 }
1988 break;
1989 case 94:
1990 amb_index |=
1991 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
1992 amb_index <<= 1;
1993 amb_index |=
1994 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag);
1995 amb_index <<= 1;
1996 amb_index |=
1997 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
1998 switch (amb_index) {
1999 case 0:
2000 case 1:
2001 case 3:
2002 case 7:
2003 get_hex_rotation_info(4, &rot_info);
2004 break;
2005 case 2:
2006 case 6:
2007 get_hex_rotation_info(11, &rot_info);
2008 break;
2009 case 4:
2010 case 5:
2011 get_hex_rotation_info(20, &rot_info);
2012 break;
2013 }
2014 break;
2015 case 91:
2016 amb_index |=
2017 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag);
2018 amb_index <<= 1;
2019 amb_index |=
2020 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
2021 amb_index <<= 1;
2022 amb_index |=
2023 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag);
2024 switch (amb_index) {
2025 case 0:
2026 case 1:
2027 case 3:
2028 case 7:
2029 get_hex_rotation_info(9, &rot_info);
2030 break;
2031 case 2:
2032 case 6:
2033 get_hex_rotation_info(3, &rot_info);
2034 break;
2035 case 4:
2036 case 5:
2037 get_hex_rotation_info(13, &rot_info);
2038 break;
2039 }
2040 break;
2041 }
2042 }
2043
2044 switch (amb_index) {
2045 case 0:
2046 cube_polys->verts_num = 14;
2047 for (i = 0; i < 14; i++) {
2048 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2049 }
2050 *cube_polys->isosurf = isosurf_A;
2051
2052 break;
2053 case 1:
2054 case 2:
2055 case 4:
2056 cube_polys->verts_num = 14;
2057 for (i = 0; i < 14; i++) {
2058 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2059 }
2060 *cube_polys->isosurf = isosurf_B;
2061
2062 break;
2063 case 3:
2064 case 5:
2065 case 6:
2066 cube_polys->verts_num = 15;
2067 for (i = 0; i < 15; i++) {
2068 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2069 }
2070 *cube_polys->isosurf = isosurf_C;
2071
2072 break;
2073 case 7:
2074 cube_polys->verts_num = 14;
2075 for (i = 0; i < 14; i++) {
2076 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2077 }
2078 *cube_polys->isosurf = isosurf_D;
2079
2080 break;
2081 }
2082 }
2083
case8_tiler_hex(int index,Cube_polygons * cube_polys)2084 void case8_tiler_hex(int index, Cube_polygons *cube_polys) {
2085 int i;
2086 Rotation_info rot_info;
2087 static int verts[8] = {1, 3, 5, 7, 200, 201, 204, 205};
2088 static int isosurf[7] = {0, 2, 1, 1, 2, 3, -1};
2089
2090 switch (index) {
2091 case 15:
2092 get_hex_rotation_info(2, &rot_info);
2093 break;
2094 case 51:
2095 get_hex_rotation_info(0, &rot_info);
2096 break;
2097 case 102:
2098 get_hex_rotation_info(5, &rot_info);
2099 break;
2100 }
2101 cube_polys->verts_num = 8;
2102 for (i = 0; i < 8; i++) {
2103 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2104 }
2105
2106 *cube_polys->isosurf = isosurf;
2107 for (i = 0; i < 6; i++) {
2108 }
2109 }
2110
case8opp_tiler_hex(int index,Cube_polygons * cube_polys)2111 void case8opp_tiler_hex(int index, Cube_polygons *cube_polys) {
2112 int i;
2113 Rotation_info rot_info;
2114 static int verts[8] = {1, 3, 5, 7, 202, 203, 206, 207};
2115 static int isosurf[7] = {0, 1, 2, 1, 3, 2, -1};
2116
2117 switch (index) {
2118 case 240:
2119 get_hex_rotation_info(2, &rot_info);
2120 break;
2121 case 204:
2122 get_hex_rotation_info(0, &rot_info);
2123 break;
2124 case 153:
2125 get_hex_rotation_info(5, &rot_info);
2126 break;
2127 }
2128 cube_polys->verts_num = 8;
2129 for (i = 0; i < 8; i++) {
2130 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2131 }
2132
2133 *cube_polys->isosurf = isosurf;
2134 for (i = 0; i < 6; i++) {
2135 }
2136 }
2137
case9_tiler_hex(int index,Cube_polygons * cube_polys)2138 void case9_tiler_hex(int index, Cube_polygons *cube_polys) {
2139 int i;
2140 Rotation_info rot_info;
2141 static int verts[10] = {0, 3, 5, 6, 9, 10, 200, 204, 205, 207};
2142 static int isosurf[13] = {1, 3, 5, 0, 3, 1, 0, 2, 3, 0, 4, 2, -1};
2143
2144 switch (index) {
2145 case 141:
2146 get_hex_rotation_info(1, &rot_info);
2147 break;
2148 case 177:
2149 get_hex_rotation_info(0, &rot_info);
2150 break;
2151 case 216:
2152 get_hex_rotation_info(10, &rot_info);
2153 break;
2154 case 228:
2155 get_hex_rotation_info(7, &rot_info);
2156 break;
2157 }
2158 cube_polys->verts_num = 10;
2159 for (i = 0; i < 10; i++) {
2160 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2161 }
2162
2163 *cube_polys->isosurf = isosurf;
2164 for (i = 0; i < 6; i++) {
2165 }
2166 }
2167
case9opp_tiler_hex(int index,Cube_polygons * cube_polys)2168 void case9opp_tiler_hex(int index, Cube_polygons *cube_polys) {
2169 int i;
2170 Rotation_info rot_info;
2171 static int verts[10] = {0, 3, 5, 6, 9, 10, 201, 202, 203, 206};
2172 static int isosurf[13] = {1, 5, 3, 0, 1, 3, 0, 3, 2, 0, 2, 4, -1};
2173
2174 switch (index) {
2175 case 114:
2176 get_hex_rotation_info(1, &rot_info);
2177 break;
2178 case 78:
2179 get_hex_rotation_info(0, &rot_info);
2180 break;
2181 case 39:
2182 get_hex_rotation_info(10, &rot_info);
2183 break;
2184 case 27:
2185 get_hex_rotation_info(7, &rot_info);
2186 break;
2187 }
2188 cube_polys->verts_num = 10;
2189 for (i = 0; i < 10; i++) {
2190 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2191 }
2192
2193 *cube_polys->isosurf = isosurf;
2194 for (i = 0; i < 6; i++) {
2195 }
2196 }
2197
case10_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)2198 void case10_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
2199 double fvalue, int CS_type, int index,
2200 Cube_polygons *cube_polys, int disamb_flag) {
2201 int i;
2202 int amb_index;
2203 Rotation_info rot_info;
2204 static int verts[13] = {0, 2, 4, 6, 8, 9, 10, 11, 200, 203, 205, 206, 106};
2205 static int isosurf_A[13] = {4, 1, 0, 1, 4, 6, 5, 7, 3, 3, 2, 5, -1};
2206 static int isosurf_B[25] = {1, 0, 12, 7, 1, 12, 5, 7, 12, 2, 5, 12, 3,
2207 2, 12, 6, 3, 12, 4, 6, 12, 0, 4, 12, -1};
2208 static int isosurf_C[13] = {6, 3, 2, 6, 2, 4, 7, 1, 0, 7, 0, 5, -1};
2209 static int isosurf_D[25] = {0, 5, 12, 5, 7, 12, 7, 3, 12, 3, 2, 12, 2,
2210 4, 12, 4, 6, 12, 6, 1, 12, 1, 0, 12, -1};
2211
2212 if (disamb_flag == 0) { /* disambiguation : none */
2213 amb_index = 0;
2214 switch (index) {
2215 case 60:
2216 get_hex_rotation_info(10, &rot_info);
2217 break;
2218 case 85:
2219 get_hex_rotation_info(2, &rot_info);
2220 break;
2221 case 105:
2222 get_hex_rotation_info(0, &rot_info);
2223 break;
2224 }
2225 } else {
2226 amb_index = 0;
2227 switch (index) {
2228 case 60:
2229 amb_index |=
2230 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2231 amb_index <<= 1;
2232 amb_index |=
2233 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
2234 get_hex_rotation_info(10, &rot_info);
2235 break;
2236 case 85:
2237 amb_index |=
2238 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
2239 amb_index <<= 1;
2240 amb_index |=
2241 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2242 get_hex_rotation_info(2, &rot_info);
2243 break;
2244 case 105:
2245 amb_index |=
2246 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
2247 amb_index <<= 1;
2248 amb_index |=
2249 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2250 get_hex_rotation_info(0, &rot_info);
2251 break;
2252 }
2253 }
2254
2255 switch (amb_index) {
2256 case 0:
2257 cube_polys->verts_num = 12;
2258 for (i = 0; i < 12; i++) {
2259 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2260 }
2261 *cube_polys->isosurf = isosurf_A;
2262
2263 break;
2264 case 1:
2265 cube_polys->verts_num = 13;
2266 for (i = 0; i < 13; i++) {
2267 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2268 }
2269 *cube_polys->isosurf = isosurf_B;
2270
2271 break;
2272 case 3:
2273 cube_polys->verts_num = 12;
2274 for (i = 0; i < 12; i++) {
2275 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2276 }
2277 *cube_polys->isosurf = isosurf_C;
2278
2279 break;
2280 case 2:
2281 cube_polys->verts_num = 13;
2282 for (i = 0; i < 13; i++) {
2283 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2284 }
2285 *cube_polys->isosurf = isosurf_D;
2286
2287 break;
2288 }
2289 }
2290
case10opp_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)2291 void case10opp_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
2292 double fvalue, int CS_type, int index,
2293 Cube_polygons *cube_polys, int disamb_flag) {
2294 int i;
2295 int amb_index;
2296 Rotation_info rot_info;
2297 static int verts[13] = {0, 2, 4, 6, 8, 9, 10, 11, 201, 202, 204, 207, 106};
2298 static int isosurf_A[13] = {4, 0, 1, 1, 6, 4, 5, 3, 7, 3, 5, 2, -1};
2299 static int isosurf_B[25] = {0, 1, 12, 1, 7, 12, 7, 5, 12, 5, 2, 12, 2,
2300 3, 12, 3, 6, 12, 6, 4, 12, 4, 0, 12, -1};
2301 static int isosurf_C[13] = {6, 2, 3, 6, 4, 2, 7, 0, 1, 7, 5, 0, -1};
2302 static int isosurf_D[25] = {5, 0, 12, 7, 5, 12, 3, 7, 12, 2, 3, 12, 4,
2303 2, 12, 6, 4, 12, 1, 6, 12, 0, 1, 12, -1};
2304
2305 if (disamb_flag == 0) { /* disambiguation : none */
2306 amb_index = 0;
2307 switch (index) {
2308 case 195:
2309 get_hex_rotation_info(10, &rot_info);
2310 break;
2311 case 170:
2312 get_hex_rotation_info(2, &rot_info);
2313 break;
2314 case 150:
2315 get_hex_rotation_info(0, &rot_info);
2316 break;
2317 }
2318 } else {
2319 amb_index = 0;
2320 switch (index) {
2321 case 195:
2322 amb_index |=
2323 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2324 amb_index <<= 1;
2325 amb_index |=
2326 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
2327 get_hex_rotation_info(10, &rot_info);
2328 break;
2329 case 170:
2330 amb_index |=
2331 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
2332 amb_index <<= 1;
2333 amb_index |=
2334 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2335 get_hex_rotation_info(2, &rot_info);
2336 break;
2337 case 150:
2338 amb_index |=
2339 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
2340 amb_index <<= 1;
2341 amb_index |=
2342 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2343 get_hex_rotation_info(0, &rot_info);
2344 break;
2345 }
2346 }
2347
2348 switch (amb_index) {
2349 case 0:
2350 cube_polys->verts_num = 12;
2351 for (i = 0; i < 12; i++) {
2352 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2353 }
2354 *cube_polys->isosurf = isosurf_A;
2355
2356 break;
2357 case 1:
2358 cube_polys->verts_num = 13;
2359 for (i = 0; i < 13; i++) {
2360 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2361 }
2362 *cube_polys->isosurf = isosurf_B;
2363
2364 break;
2365 case 3:
2366 cube_polys->verts_num = 12;
2367 for (i = 0; i < 12; i++) {
2368 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2369 }
2370 *cube_polys->isosurf = isosurf_C;
2371
2372 break;
2373 case 2:
2374 cube_polys->verts_num = 13;
2375 for (i = 0; i < 13; i++) {
2376 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2377 }
2378 *cube_polys->isosurf = isosurf_D;
2379
2380 break;
2381 }
2382 }
2383
case11_tiler_hex(int index,Cube_polygons * cube_polys)2384 void case11_tiler_hex(int index, Cube_polygons *cube_polys) {
2385 int i;
2386 Rotation_info rot_info;
2387 static int verts[10] = {0, 3, 6, 7, 9, 11, 200, 204, 205, 206};
2388 static int isosurf[13] = {0, 3, 1, 4, 3, 0, 4, 2, 3, 4, 5, 2, -1};
2389
2390 switch (index) {
2391 case 29:
2392 get_hex_rotation_info(13, &rot_info);
2393 break;
2394 case 43:
2395 get_hex_rotation_info(9, &rot_info);
2396 break;
2397 case 54:
2398 get_hex_rotation_info(8, &rot_info);
2399 break;
2400 case 71:
2401 get_hex_rotation_info(20, &rot_info);
2402 break;
2403 case 108:
2404 get_hex_rotation_info(11, &rot_info);
2405 break;
2406 case 113:
2407 get_hex_rotation_info(0, &rot_info);
2408 break;
2409 }
2410 cube_polys->verts_num = 10;
2411 for (i = 0; i < 10; i++) {
2412 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2413 }
2414
2415 *cube_polys->isosurf = isosurf;
2416 for (i = 0; i < 6; i++) {
2417 }
2418 }
2419
case11opp_tiler_hex(int index,Cube_polygons * cube_polys)2420 void case11opp_tiler_hex(int index, Cube_polygons *cube_polys) {
2421 int i;
2422 Rotation_info rot_info;
2423 static int verts[10] = {0, 3, 6, 7, 9, 11, 201, 202, 203, 207};
2424 static int isosurf[13] = {0, 1, 3, 4, 0, 3, 4, 3, 2, 4, 2, 5, -1};
2425
2426 switch (index) {
2427 case 226:
2428 get_hex_rotation_info(13, &rot_info);
2429 break;
2430 case 212:
2431 get_hex_rotation_info(9, &rot_info);
2432 break;
2433 case 201:
2434 get_hex_rotation_info(8, &rot_info);
2435 break;
2436 case 184:
2437 get_hex_rotation_info(20, &rot_info);
2438 break;
2439 case 147:
2440 get_hex_rotation_info(11, &rot_info);
2441 break;
2442 case 142:
2443 get_hex_rotation_info(0, &rot_info);
2444 break;
2445 }
2446 cube_polys->verts_num = 10;
2447 for (i = 0; i < 10; i++) {
2448 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2449 }
2450
2451 *cube_polys->isosurf = isosurf;
2452 for (i = 0; i < 6; i++) {
2453 }
2454 }
2455
case12_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)2456 void case12_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
2457 double fvalue, int CS_type, int index,
2458 Cube_polygons *cube_polys, int disamb_flag) {
2459 int i;
2460 int amb_index;
2461 Rotation_info rot_info;
2462 static int verts[12] = {0, 1, 2, 3, 5, 7, 8, 10, 201, 203, 204, 205};
2463 static int isosurf_A[13] = {7, 2, 3, 0, 1, 6, 1, 5, 6, 1, 4, 5, -1};
2464 static int isosurf_B[19] = {4, 2, 1, 4, 7, 2, 4, 0, 7, 0,
2465 3, 7, 4, 6, 0, 4, 5, 6, -1};
2466 static int isosurf_C[13] = {0, 3, 6, 2, 5, 7, 1, 5, 2, 4, 5, 1, -1};
2467 static int isosurf_D[19] = {2, 3, 6, 4, 5, 7, 4, 7, 2, 4,
2468 2, 6, 4, 6, 0, 4, 0, 1, -1};
2469
2470 if (disamb_flag == 0) { /* disambiguation : none */
2471 amb_index = 0; /* isosurf_A */
2472 switch (index) {
2473 case 30:
2474 get_hex_rotation_info(2, &rot_info);
2475 break;
2476 case 45:
2477 get_hex_rotation_info(4, &rot_info);
2478 break;
2479 case 53:
2480 get_hex_rotation_info(3, &rot_info);
2481 break;
2482 case 58:
2483 get_hex_rotation_info(0, &rot_info);
2484 break;
2485 case 75:
2486 get_hex_rotation_info(6, &rot_info);
2487 break;
2488 case 83:
2489 get_hex_rotation_info(15, &rot_info);
2490 break;
2491 case 86:
2492 get_hex_rotation_info(16, &rot_info);
2493 break;
2494 case 89:
2495 get_hex_rotation_info(21, &rot_info);
2496 break;
2497 case 92:
2498 get_hex_rotation_info(23, &rot_info);
2499 break;
2500 case 101:
2501 get_hex_rotation_info(5, &rot_info);
2502 break;
2503 case 106:
2504 get_hex_rotation_info(8, &rot_info);
2505 break;
2506 case 120:
2507 get_hex_rotation_info(22, &rot_info);
2508 break;
2509 }
2510 } else {
2511 amb_index = 0;
2512 switch (index) {
2513 case 30:
2514 amb_index |=
2515 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
2516 amb_index <<= 1;
2517 amb_index |=
2518 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2519 get_hex_rotation_info(2, &rot_info);
2520 break;
2521 case 45:
2522 amb_index |=
2523 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
2524 amb_index <<= 1;
2525 amb_index |=
2526 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
2527 get_hex_rotation_info(4, &rot_info);
2528 break;
2529 case 53:
2530 amb_index |=
2531 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
2532 amb_index <<= 1;
2533 amb_index |=
2534 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
2535 get_hex_rotation_info(3, &rot_info);
2536 break;
2537 case 58:
2538 amb_index |=
2539 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2540 amb_index <<= 1;
2541 amb_index |=
2542 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
2543 get_hex_rotation_info(0, &rot_info);
2544 break;
2545 case 75:
2546 amb_index |=
2547 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2548 amb_index <<= 1;
2549 amb_index |=
2550 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
2551 get_hex_rotation_info(6, &rot_info);
2552 break;
2553 case 83:
2554 amb_index |=
2555 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
2556 amb_index <<= 1;
2557 amb_index |=
2558 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2559 get_hex_rotation_info(15, &rot_info);
2560 break;
2561 case 86:
2562 amb_index |=
2563 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2564 amb_index <<= 1;
2565 amb_index |=
2566 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
2567 get_hex_rotation_info(16, &rot_info);
2568 break;
2569 case 89:
2570 amb_index |=
2571 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2572 amb_index <<= 1;
2573 amb_index |=
2574 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2575 get_hex_rotation_info(21, &rot_info);
2576 break;
2577 case 92:
2578 amb_index |=
2579 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2580 amb_index <<= 1;
2581 amb_index |=
2582 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2583 get_hex_rotation_info(23, &rot_info);
2584 break;
2585 case 101:
2586 amb_index |=
2587 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
2588 amb_index <<= 1;
2589 amb_index |=
2590 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
2591 get_hex_rotation_info(5, &rot_info);
2592 break;
2593 case 106:
2594 amb_index |=
2595 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
2596 amb_index <<= 1;
2597 amb_index |=
2598 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2599 get_hex_rotation_info(8, &rot_info);
2600 break;
2601 case 120:
2602 amb_index |=
2603 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2604 amb_index <<= 1;
2605 amb_index |=
2606 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2607 get_hex_rotation_info(22, &rot_info);
2608 break;
2609 }
2610 }
2611
2612 cube_polys->verts_num = 12;
2613 for (i = 0; i < 12; i++) {
2614 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2615 }
2616
2617 switch (amb_index) {
2618 case 0:
2619 *cube_polys->isosurf = isosurf_A;
2620
2621 break;
2622 case 1:
2623 *cube_polys->isosurf = isosurf_B;
2624
2625 break;
2626 case 3:
2627 *cube_polys->isosurf = isosurf_C;
2628
2629 break;
2630 case 2:
2631 *cube_polys->isosurf = isosurf_D;
2632
2633 break;
2634 }
2635 }
2636
case12opp_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)2637 void case12opp_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
2638 double fvalue, int CS_type, int index,
2639 Cube_polygons *cube_polys, int disamb_flag) {
2640 int i;
2641 int amb_index;
2642 Rotation_info rot_info;
2643 static int verts[12] = {0, 1, 2, 3, 5, 7, 8, 10, 200, 202, 206, 207};
2644 static int isosurf_A[13] = {7, 3, 2, 0, 6, 1, 1, 6, 5, 1, 5, 4, -1};
2645 static int isosurf_B[19] = {4, 1, 2, 4, 2, 7, 4, 7, 0, 0,
2646 7, 3, 4, 0, 6, 4, 6, 5, -1};
2647 static int isosurf_C[13] = {0, 6, 3, 2, 7, 5, 1, 2, 5, 4, 1, 5, -1};
2648 static int isosurf_D[19] = {2, 6, 3, 4, 7, 5, 4, 2, 7, 4,
2649 6, 2, 4, 0, 6, 4, 1, 0, -1};
2650
2651 if (disamb_flag == 0) { /* disambiguation : none */
2652 amb_index = 0;
2653 switch (index) {
2654 case 225:
2655 get_hex_rotation_info(2, &rot_info);
2656 break;
2657 case 210:
2658 get_hex_rotation_info(4, &rot_info);
2659 break;
2660 case 202:
2661 get_hex_rotation_info(3, &rot_info);
2662 break;
2663 case 197:
2664 get_hex_rotation_info(0, &rot_info);
2665 break;
2666 case 180:
2667 get_hex_rotation_info(6, &rot_info);
2668 break;
2669 case 172:
2670 get_hex_rotation_info(15, &rot_info);
2671 break;
2672 case 169:
2673 get_hex_rotation_info(16, &rot_info);
2674 break;
2675 case 166:
2676 get_hex_rotation_info(21, &rot_info);
2677 break;
2678 case 163:
2679 get_hex_rotation_info(23, &rot_info);
2680 break;
2681 case 154:
2682 get_hex_rotation_info(5, &rot_info);
2683 break;
2684 case 149:
2685 get_hex_rotation_info(8, &rot_info);
2686 break;
2687 case 135:
2688 get_hex_rotation_info(22, &rot_info);
2689 break;
2690 }
2691 } else {
2692 amb_index = 0;
2693 switch (index) {
2694 case 225:
2695 amb_index |=
2696 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
2697 amb_index <<= 1;
2698 amb_index |=
2699 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2700 get_hex_rotation_info(2, &rot_info);
2701 break;
2702 case 210:
2703 amb_index |=
2704 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
2705 amb_index <<= 1;
2706 amb_index |=
2707 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
2708 get_hex_rotation_info(4, &rot_info);
2709 break;
2710 case 202:
2711 amb_index |=
2712 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
2713 amb_index <<= 1;
2714 amb_index |=
2715 separation_test(mesh, cell, 3, fvalue, CS_type, disamb_flag);
2716 get_hex_rotation_info(3, &rot_info);
2717 break;
2718 case 197:
2719 amb_index |=
2720 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2721 amb_index <<= 1;
2722 amb_index |=
2723 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
2724 get_hex_rotation_info(0, &rot_info);
2725 break;
2726 case 180:
2727 amb_index |=
2728 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2729 amb_index <<= 1;
2730 amb_index |=
2731 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
2732 get_hex_rotation_info(6, &rot_info);
2733 break;
2734 case 172:
2735 amb_index |=
2736 separation_test(mesh, cell, 2, fvalue, CS_type, disamb_flag);
2737 amb_index <<= 1;
2738 amb_index |=
2739 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2740 get_hex_rotation_info(15, &rot_info);
2741 break;
2742 case 169:
2743 amb_index |=
2744 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2745 amb_index <<= 1;
2746 amb_index |=
2747 separation_test(mesh, cell, 10, fvalue, CS_type, disamb_flag);
2748 get_hex_rotation_info(16, &rot_info);
2749 break;
2750 case 166:
2751 amb_index |=
2752 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2753 amb_index <<= 1;
2754 amb_index |=
2755 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2756 get_hex_rotation_info(21, &rot_info);
2757 break;
2758 case 163:
2759 amb_index |=
2760 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2761 amb_index <<= 1;
2762 amb_index |=
2763 separation_test(mesh, cell, 5, fvalue, CS_type, disamb_flag);
2764 get_hex_rotation_info(23, &rot_info);
2765 break;
2766 case 154:
2767 amb_index |=
2768 separation_test(mesh, cell, 11, fvalue, CS_type, disamb_flag);
2769 amb_index <<= 1;
2770 amb_index |=
2771 separation_test(mesh, cell, 0, fvalue, CS_type, disamb_flag);
2772 get_hex_rotation_info(5, &rot_info);
2773 break;
2774 case 149:
2775 amb_index |=
2776 separation_test(mesh, cell, 1, fvalue, CS_type, disamb_flag);
2777 amb_index <<= 1;
2778 amb_index |=
2779 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2780 get_hex_rotation_info(8, &rot_info);
2781 break;
2782 case 135:
2783 amb_index |=
2784 separation_test(mesh, cell, 8, fvalue, CS_type, disamb_flag);
2785 amb_index <<= 1;
2786 amb_index |=
2787 separation_test(mesh, cell, 6, fvalue, CS_type, disamb_flag);
2788 get_hex_rotation_info(22, &rot_info);
2789 break;
2790 }
2791 }
2792
2793 cube_polys->verts_num = 12;
2794 for (i = 0; i < 12; i++) {
2795 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2796 }
2797
2798 switch (amb_index) {
2799 case 0:
2800 *cube_polys->isosurf = isosurf_A;
2801
2802 break;
2803 case 1:
2804 *cube_polys->isosurf = isosurf_B;
2805
2806 break;
2807 case 3:
2808 *cube_polys->isosurf = isosurf_C;
2809
2810 break;
2811 case 2:
2812 *cube_polys->isosurf = isosurf_D;
2813
2814 break;
2815 }
2816 }
2817
case13_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)2818 void case13_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
2819 double fvalue, int CS_type, int index,
2820 Cube_polygons *cube_polys, int disamb_flag) {
2821 int i;
2822 int amb_index;
2823 Rotation_info rot_info;
2824 static int verts[16] = {0, 1, 2, 3, 4, 5, 6, 7,
2825 8, 9, 10, 11, 200, 202, 205, 207};
2826 static int isosurf_A[13] = {2, 10, 3, 0, 9, 1, 8, 7, 4, 5, 6, 11, -1};
2827 static int isosurf_B[19] = {8, 7, 4, 5, 6, 11, 9, 1, 10, 1,
2828 2, 10, 9, 10, 3, 9, 3, 0, -1};
2829 static int isosurf_C[25] = {0, 9, 3, 9, 10, 3, 10, 9, 1, 1, 2, 10, 5,
2830 4, 11, 11, 4, 8, 11, 8, 6, 6, 8, 7, -1};
2831 static int isosurf_D[31] = {0, 9, 16, 9, 5, 16, 5, 6, 16, 6, 11,
2832 16, 11, 1, 16, 1, 2, 16, 2, 10, 16, 10,
2833 3, 16, 3, 0, 16, 4, 8, 7, -1};
2834 static int isosurf_E[37] = {
2835 0, 9, 16, 9, 5, 16, 5, 6, 16, 6, 11, 16, 11, 1, 16, 1, 2, 16, 2,
2836 10, 16, 10, 7, 16, 7, 4, 16, 4, 8, 16, 8, 3, 16, 3, 0, 16, -1};
2837 static int isosurf_F[37] = {0, 8, 16, 8, 7, 16, 7, 4, 16, 4, 9, 16, 9,
2838 5, 16, 5, 6, 16, 6, 11, 16, 11, 1, 16, 1, 2,
2839 16, 2, 10, 16, 10, 3, 16, 3, 0, 16, -1};
2840 static int isosurf_G[25] = {0, 8, 1, 1, 8, 11, 11, 8, 3, 3, 2, 11, 9,
2841 7, 4, 9, 10, 7, 9, 5, 10, 5, 6, 10, -1};
2842 static int isosurf_H[31] = {0, 8, 16, 8, 3, 16, 3, 2, 16, 2, 11,
2843 16, 11, 5, 16, 5, 4, 16, 4, 9, 16, 9,
2844 1, 16, 1, 0, 16, 6, 10, 7, -1};
2845 static int isosurf_I[19] = {8, 3, 2, 8, 2, 11, 8, 11, 0, 0,
2846 11, 1, 9, 5, 4, 10, 7, 6, -1};
2847 static int isosurf_J[13] = {0, 8, 3, 4, 9, 5, 2, 11, 1, 10, 7, 6, -1};
2848 static int isosurf_K[37] = {0, 8, 16, 8, 7, 16, 7, 4, 16, 4, 9, 16, 9,
2849 1, 16, 1, 2, 16, 2, 11, 16, 11, 5, 16, 5, 6,
2850 16, 6, 10, 16, 10, 3, 16, 3, 0, 16, -1};
2851 static int isosurf_L[19] = {2, 11, 1, 0, 10, 3, 0, 6, 10, 9,
2852 6, 0, 9, 5, 6, 8, 7, 4, -1};
2853 /*
2854 static int sep_bd[6][9] = {{3, 12,0,3, 3, 13,2,1, -1},
2855 {3, 14,5,9, 3, 13,1,11, -1},
2856 {3, 14,4,5, 3, 15,6,7, -1},
2857 {3, 12,3,8, 3, 15,7,10, -1},
2858 {3, 13,11,2, 3, 15,10,6, -1},
2859 {3, 14,9,4, 3, 12,8,0, -1}};
2860 static int not_sep_bd[6][8] = {{6, 12,0,1,13,2,3, -1},
2861 {6, 14,5,11,13,1,9, -1},
2862 {6, 14,4,7,15,6,5, -1},
2863 {6, 12,3,10,15,7,8, -1},
2864 {6, 13,11,6,15,10,2, -1},
2865 {6, 14,9,0,12,8,4, -1}};
2866 */
2867 static int cube_patch[64] = {
2868 9, 8, 8, 7, 8, 6, 7, 4, 8, 7, 6, 10, 7, 4, 10, 2, 8, 7, 7, 5, 7, 10,
2869 11, 3, 7, 11, 4, 3, 5, 3, 3, 1, 8, 7, 7, 11, 7, 10, 5, 3, 7, 5, 4, 3,
2870 11, 3, 3, 1, 6, 4, 10, 3, 4, 2, 3, 1, 10, 3, 2, 1, 3, 1, 1, 0};
2871 static int cube_rotation[64] = {
2872 0, 0, 6, 0, 15, 0, 23, 22, 2, 7, 6, 15, 15, 6, 0, 1,
2873 8, 21, 17, 15, 8, 1, 7, 22, 2, 23, 1, 1, 0, 6, 16, 1,
2874 16, 16, 6, 15, 1, 21, 7, 2, 22, 17, 8, 8, 0, 17, 21, 8,
2875 21, 15, 22, 15, 0, 6, 7, 22, 17, 23, 0, 15, 0, 6, 0, 0};
2876
2877 if (disamb_flag == 0) { /* disambiguation : none */
2878 amb_index = 9; /* isosurf_J */
2879 } else {
2880 amb_index = 0;
2881 amb_index |= separation_test(mesh, cell, 11, fvalue, CS_type,
2882 disamb_flag); /* bottom */
2883 amb_index <<= 1;
2884 amb_index |=
2885 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag); /* top */
2886 amb_index <<= 1;
2887 amb_index |=
2888 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag); /* left */
2889 amb_index <<= 1;
2890 amb_index |=
2891 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag); /* back */
2892 amb_index <<= 1;
2893 amb_index |= separation_test(mesh, cell, 3, fvalue, CS_type,
2894 disamb_flag); /* right */
2895 amb_index <<= 1;
2896 amb_index |= separation_test(mesh, cell, 0, fvalue, CS_type,
2897 disamb_flag); /* front */
2898 }
2899 get_hex_rotation_info(cube_rotation[amb_index], &rot_info);
2900
2901 switch (cube_patch[amb_index]) {
2902 case 0:
2903 cube_polys->verts_num = 16;
2904 for (i = 0; i < 16; i++) {
2905 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2906 }
2907 *cube_polys->isosurf = isosurf_A;
2908
2909 break;
2910 case 1:
2911 cube_polys->verts_num = 16;
2912 for (i = 0; i < 16; i++) {
2913 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2914 }
2915 *cube_polys->isosurf = isosurf_B;
2916
2917 break;
2918 case 2:
2919 cube_polys->verts_num = 16;
2920 for (i = 0; i < 16; i++) {
2921 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2922 }
2923 *cube_polys->isosurf = isosurf_C;
2924
2925 break;
2926 case 3:
2927 cube_polys->verts_num = 17;
2928 for (i = 0; i < 16; i++) {
2929 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2930 }
2931 cube_polys->verts[16] = point_convert(101, &rot_info);
2932 *cube_polys->isosurf = isosurf_D;
2933
2934 break;
2935 case 4:
2936 cube_polys->verts_num = 17;
2937 for (i = 0; i < 16; i++) {
2938 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2939 }
2940 cube_polys->verts[16] = point_convert(101, &rot_info);
2941 *cube_polys->isosurf = isosurf_E;
2942
2943 break;
2944 case 5:
2945 cube_polys->verts_num = 17;
2946 for (i = 0; i < 16; i++) {
2947 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2948 }
2949 cube_polys->verts[16] = point_convert(101, &rot_info);
2950 *cube_polys->isosurf = isosurf_F;
2951
2952 break;
2953 case 6:
2954 cube_polys->verts_num = 16;
2955 for (i = 0; i < 16; i++) {
2956 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2957 }
2958 *cube_polys->isosurf = isosurf_G;
2959
2960 break;
2961 case 7:
2962 cube_polys->verts_num = 17;
2963 for (i = 0; i < 16; i++) {
2964 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2965 }
2966 cube_polys->verts[16] = point_convert(102, &rot_info);
2967 *cube_polys->isosurf = isosurf_H;
2968
2969 break;
2970 case 8:
2971 cube_polys->verts_num = 16;
2972 for (i = 0; i < 16; i++) {
2973 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2974 }
2975 *cube_polys->isosurf = isosurf_I;
2976
2977 break;
2978 case 9:
2979 cube_polys->verts_num = 16;
2980 for (i = 0; i < 16; i++) {
2981 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2982 }
2983 *cube_polys->isosurf = isosurf_J;
2984
2985 break;
2986 case 10:
2987 cube_polys->verts_num = 17;
2988 for (i = 0; i < 16; i++) {
2989 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2990 }
2991 cube_polys->verts[16] = point_convert(101, &rot_info);
2992 *cube_polys->isosurf = isosurf_K;
2993
2994 break;
2995 case 11:
2996 cube_polys->verts_num = 16;
2997 for (i = 0; i < 16; i++) {
2998 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
2999 }
3000 *cube_polys->isosurf = isosurf_L;
3001
3002 break;
3003 }
3004 }
3005
case13opp_tiler_hex(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,int index,Cube_polygons * cube_polys,int disamb_flag)3006 void case13opp_tiler_hex(struct hecmwST_local_mesh *mesh, Cell *cell,
3007 double fvalue, int CS_type, int index,
3008 Cube_polygons *cube_polys, int disamb_flag) {
3009 int i;
3010 int amb_index;
3011 Rotation_info rot_info;
3012 static int verts[16] = {0, 1, 2, 3, 4, 5, 6, 7,
3013 8, 9, 10, 11, 201, 203, 204, 206};
3014 static int isosurf_A[13] = {2, 3, 10, 0, 1, 9, 8, 4, 7, 5, 11, 6, -1};
3015 static int isosurf_B[19] = {8, 4, 7, 5, 11, 6, 9, 10, 1, 1,
3016 10, 2, 9, 3, 10, 9, 0, 3, -1};
3017 static int isosurf_C[25] = {0, 3, 9, 9, 3, 10, 10, 1, 9, 1, 10, 2, 5,
3018 11, 4, 11, 8, 4, 11, 6, 8, 6, 7, 8, -1};
3019 static int isosurf_D[31] = {9, 0, 16, 5, 9, 16, 6, 5, 16, 11, 6,
3020 16, 1, 11, 16, 2, 1, 16, 10, 2, 16, 3,
3021 10, 16, 0, 3, 16, 4, 7, 8, -1};
3022 static int isosurf_E[37] = {9, 0, 16, 5, 9, 16, 6, 5, 16, 11, 6, 16, 1,
3023 11, 16, 2, 1, 16, 10, 2, 16, 7, 10, 16, 4, 7,
3024 16, 8, 4, 16, 3, 8, 16, 0, 3, 16, -1};
3025 static int isosurf_F[37] = {8, 0, 16, 7, 8, 16, 4, 7, 16, 9, 4, 16, 5,
3026 9, 16, 6, 5, 16, 11, 6, 16, 1, 11, 16, 2, 1,
3027 16, 10, 2, 16, 3, 10, 16, 0, 3, 16, -1};
3028 static int isosurf_G[25] = {0, 1, 8, 1, 11, 8, 11, 3, 8, 3, 11, 2, 9,
3029 4, 7, 9, 7, 10, 9, 10, 5, 5, 10, 6, -1};
3030 static int isosurf_H[31] = {8, 0, 16, 3, 8, 16, 2, 3, 16, 11, 2,
3031 16, 5, 11, 16, 4, 5, 16, 9, 4, 16, 1,
3032 9, 16, 0, 1, 16, 6, 7, 10, -1};
3033 static int isosurf_I[19] = {8, 2, 3, 8, 11, 2, 8, 0, 11, 0,
3034 1, 11, 9, 4, 5, 10, 6, 7, -1};
3035 static int isosurf_J[13] = {0, 3, 8, 4, 5, 9, 2, 1, 11, 10, 6, 7, -1};
3036 static int isosurf_K[37] = {8, 0, 16, 7, 8, 16, 4, 7, 16, 9, 4, 16, 1,
3037 9, 16, 2, 1, 16, 11, 2, 16, 5, 11, 16, 6, 5,
3038 16, 10, 6, 16, 3, 10, 16, 0, 3, 16, -1};
3039 static int isosurf_L[19] = {2, 1, 11, 0, 3, 10, 0, 10, 6, 9,
3040 0, 6, 9, 6, 5, 8, 4, 7, -1};
3041 /*
3042 static int sep_bd[6][9] = {{3, 12,1,0, 3, 13,3,2, -1},
3043 {3, 12,9,1, 3, 15,11,5, -1},
3044 {3, 14,7,4, 3, 15,5,6, -1},
3045 {3, 14,8,7, 3, 13,10,3, -1},
3046 {3, 13,2,10, 3, 15,6,11, -1},
3047 {3, 14,4,8, 3, 12,0,9, -1}};
3048 static int not_sep_bd[6][8] = {{6, 12,1,2,13,3,0, -1},
3049 {6, 12,9,5,15,11,1, -1},
3050 {6, 14,7,6,15,5,4, -1},
3051 {6, 14,8,3,13,10,7, -1},
3052 {6, 13,2,11,15,6,10, -1},
3053 {6, 14,4,9,12,0,8, -1}};
3054 */
3055 static int cube_patch[64] = {
3056 9, 8, 8, 7, 8, 6, 7, 4, 8, 7, 6, 10, 7, 4, 10, 2, 8, 7, 7, 5, 7, 10,
3057 11, 3, 7, 11, 4, 3, 5, 3, 3, 1, 8, 7, 7, 11, 7, 10, 5, 3, 7, 5, 4, 3,
3058 11, 3, 3, 1, 6, 4, 10, 3, 4, 2, 3, 1, 10, 3, 2, 1, 3, 1, 1, 0};
3059 static int cube_rotation[64] = {
3060 0, 0, 6, 0, 15, 0, 23, 22, 2, 7, 6, 15, 15, 6, 0, 1,
3061 8, 21, 17, 15, 8, 1, 7, 22, 2, 23, 1, 1, 0, 6, 16, 1,
3062 16, 16, 6, 15, 1, 21, 7, 2, 22, 17, 8, 8, 0, 17, 21, 8,
3063 21, 15, 22, 15, 0, 6, 7, 22, 17, 23, 0, 15, 0, 6, 0, 0};
3064
3065 if (disamb_flag == 0) { /* disambiguation : none */
3066 amb_index = 9;
3067 } else {
3068 amb_index = 0;
3069 amb_index |= separation_test(mesh, cell, 11, fvalue, CS_type,
3070 disamb_flag); /* bottom */
3071 amb_index <<= 1;
3072 amb_index |=
3073 separation_test(mesh, cell, 9, fvalue, CS_type, disamb_flag); /* top */
3074 amb_index <<= 1;
3075 amb_index |=
3076 separation_test(mesh, cell, 7, fvalue, CS_type, disamb_flag); /* left */
3077 amb_index <<= 1;
3078 amb_index |=
3079 separation_test(mesh, cell, 4, fvalue, CS_type, disamb_flag); /* back */
3080 amb_index <<= 1;
3081 amb_index |= separation_test(mesh, cell, 3, fvalue, CS_type,
3082 disamb_flag); /* right */
3083 amb_index <<= 1;
3084 amb_index |= separation_test(mesh, cell, 0, fvalue, CS_type,
3085 disamb_flag); /* front */
3086 }
3087
3088 get_hex_rotation_info(cube_rotation[amb_index], &rot_info);
3089
3090 switch (cube_patch[amb_index]) {
3091 case 0:
3092 cube_polys->verts_num = 16;
3093 for (i = 0; i < 16; i++) {
3094 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3095 }
3096 *cube_polys->isosurf = isosurf_A;
3097
3098 break;
3099 case 1:
3100 cube_polys->verts_num = 16;
3101 for (i = 0; i < 16; i++) {
3102 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3103 }
3104 *cube_polys->isosurf = isosurf_B;
3105
3106 break;
3107 case 2:
3108 cube_polys->verts_num = 16;
3109 for (i = 0; i < 16; i++) {
3110 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3111 }
3112 *cube_polys->isosurf = isosurf_C;
3113
3114 break;
3115 case 3:
3116 cube_polys->verts_num = 17;
3117 for (i = 0; i < 16; i++) {
3118 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3119 }
3120 cube_polys->verts[16] = point_convert(101, &rot_info);
3121 *cube_polys->isosurf = isosurf_D;
3122
3123 break;
3124 case 4:
3125 cube_polys->verts_num = 17;
3126 for (i = 0; i < 16; i++) {
3127 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3128 }
3129 cube_polys->verts[16] = point_convert(101, &rot_info);
3130 *cube_polys->isosurf = isosurf_E;
3131
3132 break;
3133 case 5:
3134 cube_polys->verts_num = 17;
3135 for (i = 0; i < 16; i++) {
3136 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3137 }
3138 cube_polys->verts[16] = point_convert(101, &rot_info);
3139 *cube_polys->isosurf = isosurf_F;
3140
3141 break;
3142 case 6:
3143 cube_polys->verts_num = 16;
3144 for (i = 0; i < 16; i++) {
3145 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3146 }
3147 *cube_polys->isosurf = isosurf_G;
3148
3149 break;
3150 case 7:
3151 cube_polys->verts_num = 17;
3152 for (i = 0; i < 16; i++) {
3153 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3154 }
3155 cube_polys->verts[16] = point_convert(102, &rot_info);
3156 *cube_polys->isosurf = isosurf_H;
3157
3158 break;
3159 case 8:
3160 cube_polys->verts_num = 16;
3161 for (i = 0; i < 16; i++) {
3162 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3163 }
3164 *cube_polys->isosurf = isosurf_I;
3165
3166 break;
3167 case 9:
3168 cube_polys->verts_num = 16;
3169 for (i = 0; i < 16; i++) {
3170 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3171 }
3172 *cube_polys->isosurf = isosurf_J;
3173
3174 break;
3175 case 10:
3176 cube_polys->verts_num = 17;
3177 for (i = 0; i < 16; i++) {
3178 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3179 }
3180 cube_polys->verts[16] = point_convert(101, &rot_info);
3181 *cube_polys->isosurf = isosurf_K;
3182
3183 break;
3184 case 11:
3185 cube_polys->verts_num = 16;
3186 for (i = 0; i < 16; i++) {
3187 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3188 }
3189 *cube_polys->isosurf = isosurf_L;
3190
3191 break;
3192 }
3193 }
3194
case14_tiler_hex(int index,Cube_polygons * cube_polys)3195 void case14_tiler_hex(int index, Cube_polygons *cube_polys) {
3196 int i;
3197 Rotation_info rot_info;
3198 static int verts[10] = {0, 1, 5, 6, 8, 10, 201, 204, 205, 207};
3199 static int isosurf[13] = {1, 2, 0, 0, 2, 4, 4, 2, 3, 4, 3, 5, -1};
3200
3201 switch (index) {
3202 case 139:
3203 get_hex_rotation_info(13, &rot_info);
3204 break;
3205 case 156:
3206 get_hex_rotation_info(18, &rot_info);
3207 break;
3208 case 178:
3209 get_hex_rotation_info(0, &rot_info);
3210 break;
3211 case 198:
3212 get_hex_rotation_info(11, &rot_info);
3213 break;
3214 case 209:
3215 get_hex_rotation_info(10, &rot_info);
3216 break;
3217 case 232:
3218 get_hex_rotation_info(7, &rot_info);
3219 break;
3220 }
3221 cube_polys->verts_num = 10;
3222 for (i = 0; i < 10; i++) {
3223 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3224 }
3225
3226 *cube_polys->isosurf = isosurf;
3227 for (i = 0; i < 6; i++) {
3228 }
3229 }
3230
case14opp_tiler_hex(int index,Cube_polygons * cube_polys)3231 void case14opp_tiler_hex(int index, Cube_polygons *cube_polys) {
3232 int i;
3233 Rotation_info rot_info;
3234 static int verts[10] = {0, 1, 5, 6, 8, 10, 200, 202, 203, 206};
3235 static int isosurf[13] = {1, 0, 2, 0, 4, 2, 4, 3, 2, 4, 5, 3, -1};
3236
3237 switch (index) {
3238 case 116:
3239 get_hex_rotation_info(13, &rot_info);
3240 break;
3241 case 99:
3242 get_hex_rotation_info(18, &rot_info);
3243 break;
3244 case 77:
3245 get_hex_rotation_info(0, &rot_info);
3246 break;
3247 case 57:
3248 get_hex_rotation_info(11, &rot_info);
3249 break;
3250 case 46:
3251 get_hex_rotation_info(10, &rot_info);
3252 break;
3253 case 23:
3254 get_hex_rotation_info(7, &rot_info);
3255 break;
3256 }
3257 cube_polys->verts_num = 10;
3258 for (i = 0; i < 10; i++) {
3259 cube_polys->verts[i] = point_convert(verts[i], &rot_info);
3260 }
3261
3262 *cube_polys->isosurf = isosurf;
3263 for (i = 0; i < 6; i++) {
3264 }
3265 }
3266
choice_disambiguation(int disamb_flag,double fvalue,int CS_type,double voxel0,double voxel1,double voxel2,double voxel3)3267 int choice_disambiguation(int disamb_flag, double fvalue, int CS_type,
3268 double voxel0, double voxel1, double voxel2,
3269 double voxel3) {
3270 int sep;
3271 double field;
3272
3273 switch (disamb_flag) {
3274 case 1: /* asymptotic decider */
3275 field = calc_cross_field(voxel0, voxel1, voxel2, voxel3);
3276 break;
3277 case 2: /* facial average */
3278 field = facial_average(voxel0, voxel1, voxel2, voxel3);
3279 break;
3280 }
3281
3282 if (!CS_type) {
3283 /* when alpha volume */
3284 if (voxel0 >= fvalue) {
3285 sep = (field < fvalue) ? 0 : 1;
3286 } else {
3287 sep = (field >= fvalue) ? 0 : 1;
3288 }
3289 } else {
3290 /* when beta volume */
3291 if (voxel0 <= fvalue) {
3292 sep = (field > fvalue) ? 0 : 1;
3293 } else {
3294 sep = (field <= fvalue) ? 0 : 1;
3295 }
3296 }
3297
3298 return sep;
3299 }
3300