PageRenderTime 31ms CodeModel.GetById 40ms RepoModel.GetById 0ms app.codeStats 0ms

/misc/nistmeshlab/meshlab/src/external/qhull-2003.1/src/global.c

https://github.com/lessandro/nbis
C | 1621 lines | 1328 code | 33 blank | 260 comment | 414 complexity | bfe3ed74deac8fa26dcfd78f082e649e MD5 | raw file
    

  1. /*<html><pre>  -<a                             href="qh-globa.htm"
    2. 

  2.   >-------------------------------</a><a name="TOP">-</a>
    3. 

    4. 

  4.    global.c
    5. 

  5.    initializes all the globals of the qhull application
    6. 

    7. 

  7.    see README
    8. 

    9. 

  9.    see qhull.h for qh.globals and function prototypes
    10. 

    11. 

  11.    see qhull_a.h for internal functions
    12. 

    13. 

  13.    copyright (c) 1993-2003, The Geometry Center
    14. 

  14.  */
    15. 

  15. 

  16. #include "qhull_a.h"
    17. 

  17. 

  18. /*========= qh definition (see qhull.h) =======================*/
    19. 

  19. 

  20. #if qh_QHpointer
    21. 

  21. qhT *qh_qh= NULL;	/* pointer to all global variables */
    22. 

  22. #else
    23. 

  23. qhT qh_qh;     		/* all global variables.
    24. 

  24. 			   Add "= {0}" if this causes a compiler error.
    25. 

  25. 			   Also qh_qhstat in stat.c and qhmem in mem.c.  */
    26. 

  26. #endif
    27. 

  27. 

  28. /*-<a                             href	="qh-globa.htm#TOC"
    29. 

  29.   >--------------------------------</a><a name="qh_version">-</a>
    30. 

    31. 

  31.   qh_version
    32. 

  32.     version string by year and date
    33. 

    34. 

  34.     the revision increases on code changes only
    35. 

    36. 

  36.   notes:
    37. 

  37.     change date:    Changes.txt, Announce.txt, README.txt, 
    38. 

  38.                     qhull.man, qhull.txt, qhull-news.html, Eudora signatures, 
    39. 

  39.     change version: README.txt, qh-get.htm, File_id.diz, Makefile.txt
    40. 

  40.     change year:    Copying.txt
    41. 

  41.     check download size
    42. 

  42.     recompile user_eg.c, rbox.c, qhull.c, qconvex.c, qdelaun.c qvoronoi.c, qhalf.c
    43. 

  43. */
    44. 

  44. 

  45. char *qh_version = "2003.1 2003/12/30";
    46. 

  46. 

  47. /*-<a                             href="qh-globa.htm#TOC"
    48. 

  48.   >-------------------------------</a><a name="appendprint">-</a>
    49. 

    50. 

  50.   qh_appendprint( printFormat )
    51. 

  51.     append printFormat to qh.PRINTout unless already defined
    52. 

  52. */
    53. 

  53. void qh_appendprint (qh_PRINT format) {
    54. 

  54.   int i;
    55. 

  55. 

  56.   for (i=0; i < qh_PRINTEND; i++) {
    57. 

  57.     if (qh PRINTout[i] == format && format != qh_PRINTqhull)
    58. 

  58.       break;
    59. 

  59.     if (!qh PRINTout[i]) {
    60. 

  60.       qh PRINTout[i]= format;
    61. 

  61.       break;
    62. 

  62.     }
    63. 

  63.   }
    64. 

  64. } /* appendprint */
    65. 

  65.      
    66. 

  66. /*-<a                             href="qh-globa.htm#TOC"
    67. 

  67.   >-------------------------------</a><a name="checkflags">-</a>
    68. 

  68.   
    69. 

  69.   qh_checkflags( commandStr, hiddenFlags )
    70. 

  70.     errors if commandStr contains hiddenFlags
    71. 

  71.     hiddenFlags starts and ends with a space and is space deliminated (checked)
    72. 

    73. 

  73.   notes:
    74. 

  74.     ignores first word (e.g., "qconvex i")
    75. 

  75.     use qh_strtol/strtod since strtol/strtod may or may not skip trailing spaces
    76. 

  76.   
    77. 

  77.   see:
    78. 

  78.     qh_initflags() initializes Qhull according to commandStr
    79. 

  79. */
    80. 

  80. void qh_checkflags(char *command, char *hiddenflags) {
    81. 

  81.   char *s= command, *t, *chkerr, key, opt, prevopt;
    82. 

  82.   char chkkey[]= "   ";
    83. 

  83.   char chkopt[]=  "    ";
    84. 

  84.   char chkopt2[]= "     ";
    85. 

  85. 

  86.   if (*hiddenflags != ' ' || hiddenflags[strlen(hiddenflags)-1] != ' ') {
    87. 

  87.     fprintf(qh ferr, "qhull error (qh_checkflags): hiddenflags must start and end with a space: \"%s\"", hiddenflags);
    88. 

  88.     qh_errexit(qh_ERRinput, NULL, NULL);
    89. 

  89.   }
    90. 

  90.   if (strpbrk(hiddenflags, ",\n\r\t")) { 
    91. 

  91.     fprintf(qh ferr, "qhull error (qh_checkflags): hiddenflags contains commas, newlines, or tabs: \"%s\"", hiddenflags);
    92. 

  92.     qh_errexit(qh_ERRinput, NULL, NULL);
    93. 

  93.   }
    94. 

  94.   while (*s && !isspace(*s))  /* skip program name */
    95. 

  95.     s++;
    96. 

  96.   while (*s) {
    97. 

  97.     while (*s && isspace(*s))
    98. 

  98.       s++;
    99. 

  99.     if (*s == '-')
    100. 

  100.       s++;
    101. 

  101.     if (!*s)
    102. 

  102.       break;
    103. 

  103.     key = *s++;
    104. 

  104.     chkerr = NULL;
    105. 

  105.     if (key == '\'') {         /* TO 'file name' */
    106. 

  106.       t= strchr(s, '\'');
    107. 

  107.       if (!t) {
    108. 

  108. 	fprintf(qh ferr, "qhull error (qh_checkflags): missing the 2nd single-quote for:\n%s\n", s-1);
    109. 

  109. 	qh_errexit(qh_ERRinput, NULL, NULL);
    110. 

  110.       }
    111. 

  111.       s= t+1;
    112. 

  112.       continue;
    113. 

  113.     }
    114. 

  114.     chkkey[1]= key;
    115. 

  115.     if (strstr(hiddenflags, chkkey)) {
    116. 

  116.       chkerr= chkkey;
    117. 

  117.     }else if (isupper(key)) {
    118. 

  118.       opt= ' ';
    119. 

  119.       prevopt= ' ';
    120. 

  120.       chkopt[1]= key;
    121. 

  121.       chkopt2[1]= key;
    122. 

  122.       while (!chkerr && *s && !isspace(*s)) {
    123. 

  123. 	opt= *s++;
    124. 

  124. 	if (isalpha(opt)) {
    125. 

  125. 	  chkopt[2]= opt;
    126. 

  126. 	  if (strstr(hiddenflags, chkopt))
    127. 

  127. 	    chkerr= chkopt;
    128. 

  128. 	  if (prevopt != ' ') {
    129. 

  129.  	    chkopt2[2]= prevopt;
    130. 

  130.  	    chkopt2[3]= opt;
    131. 

  131. 	    if (strstr(hiddenflags, chkopt2))
    132. 

  132. 	      chkerr= chkopt2;
    133. 

  133. 	  }
    134. 

  134. 	}else if (key == 'Q' && isdigit(opt) && prevopt != 'b' 
    135. 

  135. 	      && (prevopt == ' ' || islower(prevopt))) {
    136. 

  136.   	    chkopt[2]= opt;
    137. 

  137. 	    if (strstr(hiddenflags, chkopt))
    138. 

  138. 	      chkerr= chkopt;
    139. 

  139. 	}else {
    140. 

  140. 	  qh_strtod (s-1, &t);
    141. 

  141. 	  if (s < t)
    142. 

  142. 	    s= t;
    143. 

  143. 	}
    144. 

  144.         prevopt= opt;
    145. 

  145.       }
    146. 

  146.     }
    147. 

  147.     if (chkerr) {
    148. 

  148.       *chkerr= '\'';
    149. 

  149.       chkerr[strlen(chkerr)-1]=  '\'';
    150. 

  150.       fprintf(qh ferr, "qhull error: option %s is not used with this program.\n             It may be used with qhull.\n", chkerr);
    151. 

  151.       qh_errexit(qh_ERRinput, NULL, NULL);
    152. 

  152.     }
    153. 

  153.   }
    154. 

  154. } /* checkflags */
    155. 

  155.     
    156. 

  156. /*-<a                             href="qh-globa.htm#TOC"
    157. 

  157.   >-------------------------------</a><a name="clock">-</a>
    158. 

  158.   
    159. 

  159.   qh_clock()
    160. 

  160.     return user CPU time in 100ths (qh_SECtick)
    161. 

  161.     only defined for qh_CLOCKtype == 2
    162. 

    163. 

  163.   notes:
    164. 

  164.     use first value to determine time 0
    165. 

  165.     from Stevens '92 8.15
    166. 

  166. */
    167. 

  167. unsigned long qh_clock (void) {
    168. 

  168. 

  169. #if (qh_CLOCKtype == 2)
    170. 

  170.   struct tms time;
    171. 

  171.   static long clktck;  /* initialized first call */
    172. 

  172.   double ratio, cpu;
    173. 

  173.   unsigned long ticks;
    174. 

  174. 

  175.   if (!clktck) {
    176. 

  176.     if ((clktck= sysconf (_SC_CLK_TCK)) < 0) {
    177. 

  177.       fprintf (qh ferr, "qhull internal error (qh_clock): sysconf() failed.  Use qh_CLOCKtype 1 in user.h\n");
    178. 

  178.       qh_errexit (qh_ERRqhull, NULL, NULL);
    179. 

  179.     }
    180. 

  180.   }
    181. 

  181.   if (times (&time) == -1) {
    182. 

  182.     fprintf (qh ferr, "qhull internal error (qh_clock): times() failed.  Use qh_CLOCKtype 1 in user.h\n");
    183. 

  183.     qh_errexit (qh_ERRqhull, NULL, NULL);
    184. 

  184.   }
    185. 

  185.   ratio= qh_SECticks / (double)clktck;
    186. 

  186.   ticks= time.tms_utime * ratio;
    187. 

  187.   return ticks;
    188. 

  188. #else
    189. 

  189.   fprintf (qh ferr, "qhull internal error (qh_clock): use qh_CLOCKtype 2 in user.h\n");
    190. 

  190.   qh_errexit (qh_ERRqhull, NULL, NULL); /* never returns */
    191. 

  191.   return 0;
    192. 

  192. #endif
    193. 

  193. } /* clock */
    194. 

  194. 

  195. /*-<a                             href="qh-globa.htm#TOC"
    196. 

  196.   >-------------------------------</a><a name="freebuffers">-</a>
    197. 

    198. 

  198.   qh_freebuffers()
    199. 

  199.     free up global memory buffers
    200. 

    201. 

  201.   notes:
    202. 

  202.     must match qh_initbuffers()
    203. 

  203. */
    204. 

  204. void qh_freebuffers (void) {
    205. 

  205. 

  206.   trace5((qh ferr, "qh_freebuffers: freeing up global memory buffers\n"));
    207. 

  207.   /* allocated by qh_initqhull_buffers */
    208. 

  208.   qh_memfree (qh NEARzero, qh hull_dim * sizeof(realT));
    209. 

  209.   qh_memfree (qh lower_threshold, (qh input_dim+1) * sizeof(realT));
    210. 

  210.   qh_memfree (qh upper_threshold, (qh input_dim+1) * sizeof(realT));
    211. 

  211.   qh_memfree (qh lower_bound, (qh input_dim+1) * sizeof(realT));
    212. 

  212.   qh_memfree (qh upper_bound, (qh input_dim+1) * sizeof(realT));
    213. 

  213.   qh_memfree (qh gm_matrix, (qh hull_dim+1) * qh hull_dim * sizeof(coordT));
    214. 

  214.   qh_memfree (qh gm_row, (qh hull_dim+1) * sizeof(coordT *));
    215. 

  215.   qh NEARzero= qh lower_threshold= qh upper_threshold= NULL;
    216. 

  216.   qh lower_bound= qh upper_bound= NULL;
    217. 

  217.   qh gm_matrix= NULL;
    218. 

  218.   qh gm_row= NULL;
    219. 

  219.   qh_setfree (&qh other_points);
    220. 

  220.   qh_setfree (&qh del_vertices);
    221. 

  221.   qh_setfree (&qh coplanarset);
    222. 

  222.   if (qh line)                /* allocated by qh_readinput, freed if no error */
    223. 

  223.     free (qh line);
    224. 

  224.   if (qh half_space)
    225. 

  225.     free (qh half_space);
    226. 

  226.   if (qh temp_malloc)
    227. 

  227.     free (qh temp_malloc);
    228. 

  228.   if (qh feasible_point)      /* allocated by qh_readfeasible */
    229. 

  229.     free (qh feasible_point);
    230. 

  230.   if (qh feasible_string)     /* allocated by qh_initflags */
    231. 

  231.     free (qh feasible_string);
    232. 

  232.   qh line= qh feasible_string= NULL;
    233. 

  233.   qh half_space= qh feasible_point= qh temp_malloc= NULL;
    234. 

  234.   /* usually allocated by qh_readinput */
    235. 

  235.   if (qh first_point && qh POINTSmalloc) {
    236. 

  236.     free(qh first_point);
    237. 

  237.     qh first_point= NULL;
    238. 

  238.   }
    239. 

  239.   if (qh input_points && qh input_malloc) { /* set by qh_joggleinput */
    240. 

  240.     free (qh input_points);
    241. 

  241.     qh input_points= NULL;
    242. 

  242.   }
    243. 

  243.   trace5((qh ferr, "qh_freebuffers: finished\n"));
    244. 

  244. } /* freebuffers */
    245. 

  245. 

  246. 

  247. /*-<a                             href="qh-globa.htm#TOC"
    248. 

  248.   >-------------------------------</a><a name="freebuild">-</a>
    249. 

    250. 

  250.   qh_freebuild( allmem )
    251. 

  251.     free global memory used by qh_initbuild and qh_buildhull
    252. 

  252.     if !allmem,
    253. 

  253.       does not free short memory (freed by qh_memfreeshort)
    254. 

    255. 

  255.   design:
    256. 

  256.     free centrums
    257. 

  257.     free each vertex
    258. 

  258.     mark unattached ridges
    259. 

  259.     for each facet
    260. 

  260.       free ridges
    261. 

  261.       free outside set, coplanar set, neighbor set, ridge set, vertex set
    262. 

  262.       free facet
    263. 

  263.     free hash table
    264. 

  264.     free interior point
    265. 

  265.     free merge set
    266. 

  266.     free temporary sets
    267. 

  267. */
    268. 

  268. void qh_freebuild (boolT allmem) {
    269. 

  269.   facetT *facet;
    270. 

  270.   vertexT *vertex;
    271. 

  271.   ridgeT *ridge, **ridgep;
    272. 

  272.   mergeT *merge, **mergep;
    273. 

  273. 

  274.   trace1((qh ferr, "qh_freebuild: free memory from qh_inithull and qh_buildhull\n"));
    275. 

  275.   if (qh del_vertices)
    276. 

  276.     qh_settruncate (qh del_vertices, 0);
    277. 

  277.   if (allmem) {
    278. 

  278.     qh_clearcenters (qh_ASnone);
    279. 

  279.     while ((vertex= qh vertex_list)) {
    280. 

  280.       if (vertex->next)
    281. 

  281.         qh_delvertex (vertex);
    282. 

  282.       else {
    283. 

  283.         qh_memfree (vertex, sizeof(vertexT));
    284. 

  284.         qh newvertex_list= qh vertex_list= NULL;
    285. 

  285.       }
    286. 

  286.     }
    287. 

  287.   }else if (qh VERTEXneighbors) {
    288. 

  288.     FORALLvertices
    289. 

  289.       qh_setfreelong (&(vertex->neighbors));
    290. 

  290.   }
    291. 

  291.   qh VERTEXneighbors= False;
    292. 

  292.   qh GOODclosest= NULL;
    293. 

  293.   if (allmem) {
    294. 

  294.     FORALLfacets {
    295. 

  295.       FOREACHridge_(facet->ridges)
    296. 

  296.         ridge->seen= False;
    297. 

  297.     }
    298. 

  298.     FORALLfacets {
    299. 

  299.       if (facet->visible) {
    300. 

  300. 	FOREACHridge_(facet->ridges) {
    301. 

  301. 	  if (!otherfacet_(ridge, facet)->visible)
    302. 

  302. 	    ridge->seen= True;  /* an unattached ridge */
    303. 

  303. 	}
    304. 

  304.       }
    305. 

  305.     }
    306. 

  306.     while ((facet= qh facet_list)) {
    307. 

  307.       FOREACHridge_(facet->ridges) {
    308. 

  308.         if (ridge->seen) {
    309. 

  309.           qh_setfree(&(ridge->vertices));
    310. 

  310.           qh_memfree(ridge, sizeof(ridgeT));
    311. 

  311.         }else
    312. 

  312.           ridge->seen= True;
    313. 

  313.       }
    314. 

  314.       qh_setfree (&(facet->outsideset));
    315. 

  315.       qh_setfree (&(facet->coplanarset));
    316. 

  316.       qh_setfree (&(facet->neighbors));
    317. 

  317.       qh_setfree (&(facet->ridges));
    318. 

  318.       qh_setfree (&(facet->vertices));
    319. 

  319.       if (facet->next)
    320. 

  320.         qh_delfacet (facet);
    321. 

  321.       else {
    322. 

  322.         qh_memfree (facet, sizeof(facetT));
    323. 

  323.         qh visible_list= qh newfacet_list= qh facet_list= NULL;
    324. 

  324.       }
    325. 

  325.     }
    326. 

  326.   }else {
    327. 

  327.     FORALLfacets {
    328. 

  328.       qh_setfreelong (&(facet->outsideset));
    329. 

  329.       qh_setfreelong (&(facet->coplanarset));
    330. 

  330.       if (!facet->simplicial) {
    331. 

  331.         qh_setfreelong (&(facet->neighbors));
    332. 

  332.         qh_setfreelong (&(facet->ridges));
    333. 

  333.         qh_setfreelong (&(facet->vertices));
    334. 

  334.       }
    335. 

  335.     }
    336. 

  336.   }
    337. 

  337.   qh_setfree (&(qh hash_table));
    338. 

  338.   qh_memfree (qh interior_point, qh normal_size);
    339. 

  339.   qh interior_point= NULL;
    340. 

  340.   FOREACHmerge_(qh facet_mergeset)  /* usually empty */
    341. 

  341.     qh_memfree (merge, sizeof(mergeT));
    342. 

  342.   qh facet_mergeset= NULL;  /* temp set */
    343. 

  343.   qh degen_mergeset= NULL;  /* temp set */
    344. 

  344.   qh_settempfree_all();
    345. 

  345. } /* freebuild */
    346. 

  346. 

  347. /*-<a                             href="qh-globa.htm#TOC"
    348. 

  348.   >-------------------------------</a><a name="freeqhull">-</a>
    349. 

    350. 

  350.   qh_freeqhull( allmem )
    351. 

  351.     free global memory
    352. 

  352.     if !allmem,
    353. 

  353.       does not free short memory (freed by qh_memfreeshort)
    354. 

    355. 

  355.   notes:
    356. 

  356.     sets qh.NOerrexit in case caller forgets to
    357. 

    358. 

  358.   design:
    359. 

  359.     free global and temporary memory from qh_initbuild and qh_buildhull
    360. 

  360.     free buffers
    361. 

  361.     free statistics
    362. 

  362. */
    363. 

  363. void qh_freeqhull (boolT allmem) {
    364. 

  364. 

  365.   trace1((qh ferr, "qh_freeqhull: free global memory\n"));
    366. 

  366.   qh NOerrexit= True;  /* no more setjmp since called at exit */
    367. 

  367.   qh_freebuild (allmem);
    368. 

  368.   qh_freebuffers();
    369. 

  369.   qh_freestatistics();
    370. 

  370. #if qh_QHpointer
    371. 

  371.   free (qh_qh);
    372. 

  372.   qh_qh= NULL;
    373. 

  373. #else
    374. 

  374.   memset((char *)&qh_qh, 0, sizeof(qhT));
    375. 

  375.   qh NOerrexit= True;
    376. 

  376. #endif
    377. 

  377. } /* freeqhull */
    378. 

  378. 

  379. /*-<a                             href="qh-globa.htm#TOC"
    380. 

  380.   >-------------------------------</a><a name="init_A">-</a>
    381. 

    382. 

  382.   qh_init_A( infile, outfile, errfile, argc, argv )
    383. 

  383.     initialize memory and stdio files
    384. 

  384.     convert input options to option string (qh.qhull_command)
    385. 

    386. 

  386.   notes:
    387. 

  387.     infile may be NULL if qh_readpoints() is not called
    388. 

    389. 

  389.     errfile should always be defined.  It is used for reporting
    390. 

  390.     errors.  outfile is used for output and format options.
    391. 

    392. 

  392.     argc/argv may be 0/NULL
    393. 

    394. 

  394.     called before error handling initialized
    395. 

  395.     qh_errexit() may not be used
    396. 

  396. */
    397. 

  397. void qh_init_A (FILE *infile, FILE *outfile, FILE *errfile, int argc, char *argv[]) {
    398. 

  398.   qh_meminit (errfile);
    399. 

  399.   qh_initqhull_start (infile, outfile, errfile);
    400. 

  400.   qh_init_qhull_command (argc, argv);
    401. 

  401. } /* init_A */
    402. 

  402. 

  403. /*-<a                             href="qh-globa.htm#TOC"
    404. 

  404.   >-------------------------------</a><a name="init_B">-</a>
    405. 

    406. 

  406.   qh_init_B( points, numpoints, dim, ismalloc )
    407. 

  407.     initialize globals for points array
    408. 

    409. 

  409.     points has numpoints dim-dimensional points
    410. 

  410.       points[0] is the first coordinate of the first point
    411. 

  411.       points[1] is the second coordinate of the first point
    412. 

  412.       points[dim] is the first coordinate of the second point
    413. 

    414. 

  414.     ismalloc=True
    415. 

  415.       Qhull will call free(points) on exit or input transformation
    416. 

  416.     ismalloc=False
    417. 

  417.       Qhull will allocate a new point array if needed for input transformation
    418. 

    419. 

  419.     qh.qhull_command
    420. 

  420.       is the option string.
    421. 

  421.       It is defined by qh_init_B(), qh_qhull_command(), or qh_initflags
    422. 

    423. 

  423.   returns:
    424. 

  424.     if qh.PROJECTinput or (qh.DELAUNAY and qh.PROJECTdelaunay)
    425. 

  425.       projects the input to a new point array
    426. 

    427. 

  427.         if qh.DELAUNAY,
    428. 

  428.           qh.hull_dim is increased by one
    429. 

  429.         if qh.ATinfinity,
    430. 

  430.           qh_projectinput adds point-at-infinity for Delaunay tri.
    431. 

    432. 

  432.     if qh.SCALEinput
    433. 

  433.       changes the upper and lower bounds of the input, see qh_scaleinput()
    434. 

    435. 

  435.     if qh.ROTATEinput
    436. 

  436.       rotates the input by a random rotation, see qh_rotateinput()
    437. 

  437.       if qh.DELAUNAY
    438. 

  438.         rotates about the last coordinate
    439. 

    440. 

  440.   notes:
    441. 

  441.     called after points are defined
    442. 

  442.     qh_errexit() may be used
    443. 

  443. */
    444. 

  444. void qh_init_B (coordT *points, int numpoints, int dim, boolT ismalloc) {
    445. 

  445.   qh_initqhull_globals (points, numpoints, dim, ismalloc);
    446. 

  446.   if (qhmem.LASTsize == 0)
    447. 

  447.     qh_initqhull_mem();
    448. 

  448.   /* mem.c and qset.c are initialized */
    449. 

  449.   qh_initqhull_buffers();
    450. 

  450.   qh_initthresholds (qh qhull_command);
    451. 

  451.   if (qh PROJECTinput || (qh DELAUNAY && qh PROJECTdelaunay))
    452. 

  452.     qh_projectinput();
    453. 

  453.   if (qh SCALEinput)
    454. 

  454.     qh_scaleinput();
    455. 

  455.   if (qh ROTATErandom >= 0) {
    456. 

  456.     qh_randommatrix (qh gm_matrix, qh hull_dim, qh gm_row);
    457. 

  457.     if (qh DELAUNAY) {
    458. 

  458.       int k, lastk= qh hull_dim-1;
    459. 

  459.       for (k= 0; k < lastk; k++) {
    460. 

  460.         qh gm_row[k][lastk]= 0.0;
    461. 

  461.         qh gm_row[lastk][k]= 0.0;
    462. 

  462.       }
    463. 

  463.       qh gm_row[lastk][lastk]= 1.0;
    464. 

  464.     }
    465. 

  465.     qh_gram_schmidt (qh hull_dim, qh gm_row);
    466. 

  466.     qh_rotateinput (qh gm_row);
    467. 

  467.   }
    468. 

  468. } /* init_B */
    469. 

  469. 

  470. /*-<a                             href="qh-globa.htm#TOC"
    471. 

  471.   >-------------------------------</a><a name="init_qhull_command">-</a>
    472. 

    473. 

  473.   qh_init_qhull_command( argc, argv )
    474. 

  474.     build qh.qhull_command from argc/argv
    475. 

    476. 

  476.   returns:
    477. 

  477.     a space-deliminated string of options (just as typed)
    478. 

    479. 

  479.   notes:
    480. 

  480.     makes option string easy to input and output
    481. 

    482. 

  482.     argc/argv may be 0/NULL
    483. 

  483. */
    484. 

  484. void qh_init_qhull_command(int argc, char *argv[]) {
    485. 

  485.   int i;
    486. 

  486.   char *s;
    487. 

  487. 

  488.   if (argc) {
    489. 

  489.     if ((s= strrchr( argv[0], '\\'))) /* Borland gives full path */
    490. 

  490.       strcpy (qh qhull_command, s+1);
    491. 

  491.     else
    492. 

  492.       strcpy (qh qhull_command, argv[0]);
    493. 

  493.     if ((s= strstr (qh qhull_command, ".EXE"))
    494. 

  494.     ||  (s= strstr (qh qhull_command, ".exe")))
    495. 

  495.       *s= '\0';
    496. 

  496.   }
    497. 

  497.   for (i=1; i < argc; i++) {
    498. 

  498.     if (strlen (qh qhull_command) + strlen(argv[i]) + 1 < sizeof(qh qhull_command)) {
    499. 

  499.       strcat (qh qhull_command, " ");
    500. 

  500.       strcat (qh qhull_command, argv[i]);
    501. 

  501.     }else {
    502. 

  502.       fprintf (qh ferr, "qhull input error: more than %d characters in command line\n",
    503. 

  503.         (int)sizeof(qh qhull_command));
    504. 

  504.       exit (1);  /* can not use qh_errexit */
    505. 

  505.     }
    506. 

  506.   }
    507. 

  507. } /* init_qhull_command */
    508. 

  508. 

  509. /*-<a                             href="qh-globa.htm#TOC"
    510. 

  510.   >-------------------------------</a><a name="initflags">-</a>
    511. 

    512. 

  512.   qh_initflags( commandStr )
    513. 

  513.     set flags and initialized constants from commandStr
    514. 

    515. 

  515.   returns:
    516. 

  516.     sets qh.qhull_command to command if needed
    517. 

    518. 

  518.   notes:
    519. 

  519.     ignores first word (e.g., "qhull d")
    520. 

  520.     use qh_strtol/strtod since strtol/strtod may or may not skip trailing spaces
    521. 

    522. 

  522.   see:
    523. 

  523.     qh_initthresholds() continues processing of 'Pdn' and 'PDn'
    524. 

  524.     'prompt' in unix.c for documentation
    525. 

    526. 

  526.   design:
    527. 

  527.     for each space-deliminated option group
    528. 

  528.       if top-level option
    529. 

  529.         check syntax
    530. 

  530.         append approriate option to option string
    531. 

  531.         set appropriate global variable or append printFormat to print options
    532. 

  532.       else
    533. 

  533.         for each sub-option
    534. 

  534.           check syntax
    535. 

  535.           append approriate option to option string
    536. 

  536.           set appropriate global variable or append printFormat to print options
    537. 

    538. 

    539. 

  539. */
    540. 

  540. void qh_initflags(char *command) {
    541. 

  541.   int k, i, lastproject;
    542. 

  542.   char *s= command, *t, *prev_s, *start, key;
    543. 

  543.   boolT isgeom= False, wasproject;
    544. 

  544.   realT r;
    545. 

  545. 

  546.   if (command != &qh qhull_command[0]) {
    547. 

  547.     *qh qhull_command= '\0';
    548. 

  548.     strncat( qh qhull_command, command, sizeof( qh qhull_command));
    549. 

  549.   }
    550. 

  550.   while (*s && !isspace(*s))  /* skip program name */
    551. 

  551.     s++;
    552. 

  552.   while (*s) {
    553. 

  553.     while (*s && isspace(*s))
    554. 

  554.       s++;
    555. 

  555.     if (*s == '-')
    556. 

  556.       s++;
    557. 

  557.     if (!*s)
    558. 

  558.       break;
    559. 

  559.     prev_s= s;
    560. 

  560.     switch (*s++) {
    561. 

  561.     case 'd':
    562. 

  562.       qh_option ("delaunay", NULL, NULL);
    563. 

  563.       qh DELAUNAY= True;
    564. 

  564.       break;
    565. 

  565.     case 'f':
    566. 

  566.       qh_option ("facets", NULL, NULL);
    567. 

  567.       qh_appendprint (qh_PRINTfacets);
    568. 

  568.       break;
    569. 

  569.     case 'i':
    570. 

  570.       qh_option ("incidence", NULL, NULL);
    571. 

  571.       qh_appendprint (qh_PRINTincidences);
    572. 

  572.       break;
    573. 

  573.     case 'm':
    574. 

  574.       qh_option ("mathematica", NULL, NULL);
    575. 

  575.       qh_appendprint (qh_PRINTmathematica);
    576. 

  576.       break;
    577. 

  577.     case 'n':
    578. 

  578.       qh_option ("normals", NULL, NULL);
    579. 

  579.       qh_appendprint (qh_PRINTnormals);
    580. 

  580.       break;
    581. 

  581.     case 'o':
    582. 

  582.       qh_option ("offFile", NULL, NULL);
    583. 

  583.       qh_appendprint (qh_PRINToff);
    584. 

  584.       break;
    585. 

  585.     case 'p':
    586. 

  586.       qh_option ("points", NULL, NULL);
    587. 

  587.       qh_appendprint (qh_PRINTpoints);
    588. 

  588.       break;
    589. 

  589.     case 's':
    590. 

  590.       qh_option ("summary", NULL, NULL);
    591. 

  591.       qh PRINTsummary= True;
    592. 

  592.       break;
    593. 

  593.     case 'v':
    594. 

  594.       qh_option ("voronoi", NULL, NULL);
    595. 

  595.       qh VORONOI= True;
    596. 

  596.       qh DELAUNAY= True;
    597. 

  597.       break;
    598. 

  598.     case 'A':
    599. 

  599.       if (!isdigit(*s) && *s != '.' && *s != '-')
    600. 

  600. 	fprintf(qh ferr, "qhull warning: no maximum cosine angle given for option 'An'.  Ignored.\n");
    601. 

  601.       else {
    602. 

  602. 	if (*s == '-') {
    603. 

  603. 	  qh premerge_cos= -qh_strtod (s, &s);
    604. 

  604.           qh_option ("Angle-premerge-", NULL, &qh premerge_cos);
    605. 

  605. 	  qh PREmerge= True;
    606. 

  606. 	}else {
    607. 

  607. 	  qh postmerge_cos= qh_strtod (s, &s);
    608. 

  608.           qh_option ("Angle-postmerge", NULL, &qh postmerge_cos);
    609. 

  609. 	  qh POSTmerge= True;
    610. 

  610. 	}
    611. 

  611. 	qh MERGING= True;
    612. 

  612.       }
    613. 

  613.       break;
    614. 

  614.     case 'C':
    615. 

  615.       if (!isdigit(*s) && *s != '.' && *s != '-')
    616. 

  616. 	fprintf(qh ferr, "qhull warning: no centrum radius given for option 'Cn'.  Ignored.\n");
    617. 

  617.       else {
    618. 

  618. 	if (*s == '-') {
    619. 

  619. 	  qh premerge_centrum= -qh_strtod (s, &s);
    620. 

  620.           qh_option ("Centrum-premerge-", NULL, &qh premerge_centrum);
    621. 

  621. 	  qh PREmerge= True;
    622. 

  622. 	}else {
    623. 

  623. 	  qh postmerge_centrum= qh_strtod (s, &s);
    624. 

  624.           qh_option ("Centrum-postmerge", NULL, &qh postmerge_centrum);
    625. 

  625. 	  qh POSTmerge= True;
    626. 

  626. 	}
    627. 

  627. 	qh MERGING= True;
    628. 

  628.       }
    629. 

  629.       break;
    630. 

  630.     case 'E':
    631. 

  631.       if (*s == '-')
    632. 

  632. 	fprintf(qh ferr, "qhull warning: negative maximum roundoff given for option 'An'.  Ignored.\n");
    633. 

  633.       else if (!isdigit(*s))
    634. 

  634. 	fprintf(qh ferr, "qhull warning: no maximum roundoff given for option 'En'.  Ignored.\n");
    635. 

  635.       else {
    636. 

  636. 	qh DISTround= qh_strtod (s, &s);
    637. 

  637.         qh_option ("Distance-roundoff", NULL, &qh DISTround);
    638. 

  638. 	qh SETroundoff= True;
    639. 

  639.       }
    640. 

  640.       break;
    641. 

  641.     case 'H':
    642. 

  642.       start= s;
    643. 

  643.       qh HALFspace= True;
    644. 

  644.       qh_strtod (s, &t);
    645. 

  645.       while (t > s)  {
    646. 

  646.         if (*t && !isspace (*t)) {
    647. 

  647. 	  if (*t == ',')
    648. 

  648. 	    t++;
    649. 

  649. 	  else
    650. 

  650. 	    fprintf (qh ferr, "qhull warning: origin for Halfspace intersection should be 'Hn,n,n,...'\n");
    651. 

  651. 	}
    652. 

  652.         s= t;
    653. 

  653. 	qh_strtod (s, &t);
    654. 

  654.       }
    655. 

  655.       if (start < t) {
    656. 

  656.         if (!(qh feasible_string= (char*)calloc (t-start+1, 1))) {
    657. 

  657.           fprintf(qh ferr, "qhull error: insufficient memory for 'Hn,n,n'\n");
    658. 

  658.           qh_errexit(qh_ERRmem, NULL, NULL);
    659. 

  659.         }
    660. 

  660.         strncpy (qh feasible_string, start, t-start);
    661. 

  661.         qh_option ("Halfspace-about", NULL, NULL);
    662. 

  662.         qh_option (qh feasible_string, NULL, NULL);
    663. 

  663.       }else
    664. 

  664.         qh_option ("Halfspace", NULL, NULL);
    665. 

  665.       break;
    666. 

  666.     case 'R':
    667. 

  667.       if (!isdigit(*s))
    668. 

  668. 	fprintf(qh ferr, "qhull warning: missing random perturbation for option 'Rn'.  Ignored\n");
    669. 

  669.       else {
    670. 

  670. 	qh RANDOMfactor= qh_strtod (s, &s);
    671. 

  671.         qh_option ("Random_perturb", NULL, &qh RANDOMfactor);
    672. 

  672.         qh RANDOMdist= True;
    673. 

  673.       }
    674. 

  674.       break;
    675. 

  675.     case 'V':
    676. 

  676.       if (!isdigit(*s) && *s != '-')
    677. 

  677. 	fprintf(qh ferr, "qhull warning: missing visible distance for option 'Vn'.  Ignored\n");
    678. 

  678.       else {
    679. 

  679. 	qh MINvisible= qh_strtod (s, &s);
    680. 

  680.         qh_option ("Visible", NULL, &qh MINvisible);
    681. 

  681.       }
    682. 

  682.       break;
    683. 

  683.     case 'U':
    684. 

  684.       if (!isdigit(*s) && *s != '-')
    685. 

  685. 	fprintf(qh ferr, "qhull warning: missing coplanar distance for option 'Un'.  Ignored\n");
    686. 

  686.       else {
    687. 

  687. 	qh MAXcoplanar= qh_strtod (s, &s);
    688. 

  688.         qh_option ("U-coplanar", NULL, &qh MAXcoplanar);
    689. 

  689.       }
    690. 

  690.       break;
    691. 

  691.     case 'W':
    692. 

  692.       if (*s == '-')
    693. 

  693. 	fprintf(qh ferr, "qhull warning: negative outside width for option 'Wn'.  Ignored.\n");
    694. 

  694.       else if (!isdigit(*s))
    695. 

  695. 	fprintf(qh ferr, "qhull warning: missing outside width for option 'Wn'.  Ignored\n");
    696. 

  696.       else {
    697. 

  697. 	qh MINoutside= qh_strtod (s, &s);
    698. 

  698.         qh_option ("W-outside", NULL, &qh MINoutside);
    699. 

  699.         qh APPROXhull= True;
    700. 

  700.       }
    701. 

  701.       break;
    702. 

  702.     /************  sub menus ***************/
    703. 

  703.     case 'F':
    704. 

  704.       while (*s && !isspace(*s)) {
    705. 

  705. 	switch(*s++) {
    706. 

  706. 	case 'a':
    707. 

  707. 	  qh_option ("Farea", NULL, NULL);
    708. 

  708. 	  qh_appendprint (qh_PRINTarea);
    709. 

  709. 	  qh GETarea= True;
    710. 

  710. 	  break;
    711. 

  711. 	case 'A':
    712. 

  712. 	  qh_option ("FArea-total", NULL, NULL);
    713. 

  713. 	  qh GETarea= True;
    714. 

  714. 	  break;
    715. 

  715.         case 'c':
    716. 

  716.           qh_option ("Fcoplanars", NULL, NULL);
    717. 

  717.           qh_appendprint (qh_PRINTcoplanars);
    718. 

  718.           break;
    719. 

  719.         case 'C':
    720. 

  720.           qh_option ("FCentrums", NULL, NULL);
    721. 

  721.           qh_appendprint (qh_PRINTcentrums);
    722. 

  722.           break;
    723. 

  723. 	case 'd':
    724. 

  724.           qh_option ("Fd-cdd-in", NULL, NULL);
    725. 

  725. 	  qh CDDinput= True;
    726. 

  726. 	  break;
    727. 

  727. 	case 'D':
    728. 

  728.           qh_option ("FD-cdd-out", NULL, NULL);
    729. 

  729. 	  qh CDDoutput= True;
    730. 

  730. 	  break;
    731. 

  731. 	case 'F':
    732. 

  732. 	  qh_option ("FFacets-xridge", NULL, NULL);
    733. 

  733.           qh_appendprint (qh_PRINTfacets_xridge);
    734. 

  734. 	  break;
    735. 

  735.         case 'i':
    736. 

  736.           qh_option ("Finner", NULL, NULL);
    737. 

  737.           qh_appendprint (qh_PRINTinner);
    738. 

  738.           break;
    739. 

  739.         case 'I':
    740. 

  740.           qh_option ("FIDs", NULL, NULL);
    741. 

  741.           qh_appendprint (qh_PRINTids);
    742. 

  742.           break;
    743. 

  743.         case 'm':
    744. 

  744.           qh_option ("Fmerges", NULL, NULL);
    745. 

  745.           qh_appendprint (qh_PRINTmerges);
    746. 

  746.           break;
    747. 

  747.         case 'M':
    748. 

  748.           qh_option ("FMaple", NULL, NULL);
    749. 

  749.           qh_appendprint (qh_PRINTmaple);
    750. 

  750.           break;
    751. 

  751.         case 'n':
    752. 

  752.           qh_option ("Fneighbors", NULL, NULL);
    753. 

  753.           qh_appendprint (qh_PRINTneighbors);
    754. 

  754.           break;
    755. 

  755.         case 'N':
    756. 

  756.           qh_option ("FNeighbors-vertex", NULL, NULL);
    757. 

  757.           qh_appendprint (qh_PRINTvneighbors);
    758. 

  758.           break;
    759. 

  759.         case 'o':
    760. 

  760.           qh_option ("Fouter", NULL, NULL);
    761. 

  761.           qh_appendprint (qh_PRINTouter);
    762. 

  762.           break;
    763. 

  763. 	case 'O':
    764. 

  764. 	  if (qh PRINToptions1st) {
    765. 

  765. 	    qh_option ("FOptions", NULL, NULL);
    766. 

  766. 	    qh_appendprint (qh_PRINToptions);
    767. 

  767. 	  }else
    768. 

  768. 	    qh PRINToptions1st= True;
    769. 

  769. 	  break;
    770. 

  770. 	case 'p':
    771. 

  771. 	  qh_option ("Fpoint-intersect", NULL, NULL);
    772. 

  772. 	  qh_appendprint (qh_PRINTpointintersect);
    773. 

  773. 	  break;
    774. 

  774. 	case 'P':
    775. 

  775. 	  qh_option ("FPoint-nearest", NULL, NULL);
    776. 

  776. 	  qh_appendprint (qh_PRINTpointnearest);
    777. 

  777. 	  break;
    778. 

  778. 	case 'Q':
    779. 

  779. 	  qh_option ("FQhull", NULL, NULL);
    780. 

  780. 	  qh_appendprint (qh_PRINTqhull);
    781. 

  781. 	  break;
    782. 

  782.         case 's':
    783. 

  783.           qh_option ("Fsummary", NULL, NULL);
    784. 

  784.           qh_appendprint (qh_PRINTsummary);
    785. 

  785.           break;
    786. 

  786.         case 'S':
    787. 

  787.           qh_option ("FSize", NULL, NULL);
    788. 

  788.           qh_appendprint (qh_PRINTsize);
    789. 

  789.           qh GETarea= True;
    790. 

  790.           break;
    791. 

  791.         case 't':
    792. 

  792.           qh_option ("Ftriangles", NULL, NULL);
    793. 

  793.           qh_appendprint (qh_PRINTtriangles);
    794. 

  794.           break;
    795. 

  795.         case 'v':
    796. 

  796.           /* option set in qh_initqhull_globals */
    797. 

  797.           qh_appendprint (qh_PRINTvertices);
    798. 

  798.           break;
    799. 

  799.         case 'V':
    800. 

  800.           qh_option ("FVertex-average", NULL, NULL);
    801. 

  801.           qh_appendprint (qh_PRINTaverage);
    802. 

  802.           break;
    803. 

  803. 	case 'x':
    804. 

  804. 	  qh_option ("Fxtremes", NULL, NULL);
    805. 

  805. 	  qh_appendprint (qh_PRINTextremes);
    806. 

  806. 	  break;
    807. 

  807. 	default:
    808. 

  808. 	  s--;
    809. 

  809. 	  fprintf (qh ferr, "qhull warning: unknown 'F' output option %c, rest ignored\n", (int)s[0]);
    810. 

  810. 	  while (*++s && !isspace(*s));
    811. 

  811. 	  break;
    812. 

  812. 	}
    813. 

  813.       }
    814. 

  814.       break;
    815. 

  815.     case 'G':
    816. 

  816.       isgeom= True;
    817. 

  817.       qh_appendprint (qh_PRINTgeom);
    818. 

  818.       while (*s && !isspace(*s)) {
    819. 

  819. 	switch(*s++) {
    820. 

  820.         case 'a':
    821. 

  821.           qh_option ("Gall-points", NULL, NULL);
    822. 

  822.           qh PRINTdots= True;
    823. 

  823.           break;
    824. 

  824.         case 'c':
    825. 

  825.           qh_option ("Gcentrums", NULL, NULL);
    826. 

  826.           qh PRINTcentrums= True;
    827. 

  827.           break;
    828. 

  828. 	case 'h':
    829. 

  829.           qh_option ("Gintersections", NULL, NULL);
    830. 

  830. 	  qh DOintersections= True;
    831. 

  831. 	  break;
    832. 

  832. 	case 'i':
    833. 

  833.           qh_option ("Ginner", NULL, NULL);
    834. 

  834. 	  qh PRINTinner= True;
    835. 

  835. 	  break;
    836. 

  836. 	case 'n':
    837. 

  837.           qh_option ("Gno-planes", NULL, NULL);
    838. 

  838. 	  qh PRINTnoplanes= True;
    839. 

  839. 	  break;
    840. 

  840. 	case 'o':
    841. 

  841.           qh_option ("Gouter", NULL, NULL);
    842. 

  842. 	  qh PRINTouter= True;
    843. 

  843. 	  break;
    844. 

  844. 	case 'p':
    845. 

  845.           qh_option ("Gpoints", NULL, NULL);
    846. 

  846. 	  qh PRINTcoplanar= True;
    847. 

  847. 	  break;
    848. 

  848. 	case 'r':
    849. 

  849.           qh_option ("Gridges", NULL, NULL);
    850. 

  850. 	  qh PRINTridges= True;
    851. 

  851. 	  break;
    852. 

  852. 	case 't':
    853. 

  853.           qh_option ("Gtransparent", NULL, NULL);
    854. 

  854. 	  qh PRINTtransparent= True;
    855. 

  855. 	  break;
    856. 

  856. 	case 'v':
    857. 

  857.           qh_option ("Gvertices", NULL, NULL);
    858. 

  858. 	  qh PRINTspheres= True;
    859. 

  859. 	  break;
    860. 

  860. 	case 'D':
    861. 

  861. 	  if (!isdigit (*s))
    862. 

  862. 	    fprintf (qh ferr, "qhull input error: missing dimension for option 'GDn'\n");
    863. 

  863. 	  else {
    864. 

  864. 	    if (qh DROPdim >= 0)
    865. 

  865. 	      fprintf (qh ferr, "qhull warning: can only drop one dimension.  Previous 'GD%d' ignored\n",
    866. 

  866. 	           qh DROPdim);
    867. 

  867.   	    qh DROPdim= qh_strtol (s, &s);
    868. 

  868.             qh_option ("GDrop-dim", &qh DROPdim, NULL);
    869. 

  869.           }
    870. 

  870. 	  break;
    871. 

  871. 	default:
    872. 

  872. 	  s--;
    873. 

  873. 	  fprintf (qh ferr, "qhull warning: unknown 'G' print option %c, rest ignored\n", (int)s[0]);
    874. 

  874. 	  while (*++s && !isspace(*s));
    875. 

  875. 	  break;
    876. 

  876. 	}
    877. 

  877.       }
    878. 

  878.       break;
    879. 

  879.     case 'P':
    880. 

  880.       while (*s && !isspace(*s)) {
    881. 

  881. 	switch(*s++) {
    882. 

  882. 	case 'd': case 'D':  /* see qh_initthresholds() */
    883. 

  883. 	  key= s[-1];
    884. 

  884. 	  i= qh_strtol (s, &s);
    885. 

  885. 	  r= 0;
    886. 

  886. 	  if (*s == ':') {
    887. 

  887. 	    s++;
    888. 

  888. 	    r= qh_strtod (s, &s);
    889. 

  889. 	  }
    890. 

  890. 	  if (key == 'd')
    891. 

  891.   	    qh_option ("Pdrop-facets-dim-less", &i, &r);
    892. 

  892.   	  else
    893. 

  893.   	    qh_option ("PDrop-facets-dim-more", &i, &r);
    894. 

  894. 	  break;
    895. 

  895.         case 'g':
    896. 

  896.           qh_option ("Pgood-facets", NULL, NULL);
    897. 

  897.           qh PRINTgood= True;
    898. 

  898.           break;
    899. 

  899.         case 'G':
    900. 

  900.           qh_option ("PGood-facet-neighbors", NULL, NULL);
    901. 

  901.           qh PRINTneighbors= True;
    902. 

  902.           break;
    903. 

  903.         case 'o':
    904. 

  904.           qh_option ("Poutput-forced", NULL, NULL);
    905. 

  905.           qh FORCEoutput= True;
    906. 

  906.           break;
    907. 

  907.         case 'p':
    908. 

  908.           qh_option ("Pprecision-ignore", NULL, NULL);
    909. 

  909.           qh PRINTprecision= False;
    910. 

  910.           break;
    911. 

  911. 	case 'A':
    912. 

  912. 	  if (!isdigit (*s))
    913. 

  913. 	    fprintf (qh ferr, "qhull input error: missing facet count for keep area option 'PAn'\n");
    914. 

  914. 	  else {
    915. 

  915.   	    qh KEEParea= qh_strtol (s, &s);
    916. 

  916.             qh_option ("PArea-keep", &qh KEEParea, NULL);
    917. 

  917.             qh GETarea= True;
    918. 

  918.           }
    919. 

  919. 	  break;
    920. 

  920. 	case 'F':
    921. 

  921. 	  if (!isdigit (*s))
    922. 

  922. 	    fprintf (qh ferr, "qhull input error: missing facet area for option 'PFn'\n");
    923. 

  923. 	  else {
    924. 

  924.   	    qh KEEPminArea= qh_strtod (s, &s);
    925. 

  925.             qh_option ("PFacet-area-keep", NULL, &qh KEEPminArea);
    926. 

  926.             qh GETarea= True;
    927. 

  927.           }
    928. 

  928. 	  break;
    929. 

  929. 	case 'M':
    930. 

  930. 	  if (!isdigit (*s))
    931. 

  931. 	    fprintf (qh ferr, "qhull input error: missing merge count for option 'PMn'\n");
    932. 

  932. 	  else {
    933. 

  933.   	    qh KEEPmerge= qh_strtol (s, &s);
    934. 

  934.             qh_option ("PMerge-keep", &qh KEEPmerge, NULL);
    935. 

  935.           }
    936. 

  936. 	  break;
    937. 

  937. 	default:
    938. 

  938. 	  s--;
    939. 

  939. 	  fprintf (qh ferr, "qhull warning: unknown 'P' print option %c, rest ignored\n", (int)s[0]);
    940. 

  940. 	  while (*++s && !isspace(*s));
    941. 

  941. 	  break;
    942. 

  942. 	}
    943. 

  943.       }
    944. 

  944.       break;
    945. 

  945.     case 'Q':
    946. 

  946.       lastproject= -1;
    947. 

  947.       while (*s && !isspace(*s)) {
    948. 

  948. 	switch(*s++) {
    949. 

  949. 	case 'b': case 'B':  /* handled by qh_initthresholds */
    950. 

  950. 	  key= s[-1];
    951. 

  951. 	  if (key == 'b' && *s == 'B') {
    952. 

  952. 	    s++;
    953. 

  953. 	    r= qh_DEFAULTbox;
    954. 

  954. 	    qh SCALEinput= True;
    955. 

  955. 	    qh_option ("QbBound-unit-box", NULL, &r);
    956. 

  956. 	    break;
    957. 

  957. 	  }
    958. 

  958. 	  if (key == 'b' && *s == 'b') {
    959. 

  959. 	    s++;
    960. 

  960. 	    qh SCALElast= True;
    961. 

  961. 	    qh_option ("Qbbound-last", NULL, NULL);
    962. 

  962. 	    break;
    963. 

  963. 	  }
    964. 

  964. 	  k= qh_strtol (s, &s);
    965. 

  965. 	  r= 0.0;
    966. 

  966. 	  wasproject= False;
    967. 

  967. 	  if (*s == ':') {
    968. 

  968. 	    s++;
    969. 

  969. 	    if ((r= qh_strtod(s, &s)) == 0.0) {
    970. 

  970.  	      t= s;            /* need true dimension for memory allocation */
    971. 

  971. 	      while (*t && !isspace(*t)) {
    972. 

  972. 	        if (toupper(*t++) == 'B'
    973. 

  973. 	         && k == qh_strtol (t, &t)
    974. 

  974. 	         && *t++ == ':'
    975. 

  975. 	         && qh_strtod(t, &t) == 0.0) {
    976. 

  976. 	          qh PROJECTinput++;
    977. 

  977. 	          trace2((qh ferr, "qh_initflags: project dimension %d\n", k));
    978. 

  978. 	          qh_option ("Qb-project-dim", &k, NULL);
    979. 

  979. 		  wasproject= True;
    980. 

  980. 	          lastproject= k;
    981. 

  981. 	          break;
    982. 

  982. 		}
    983. 

  983. 	      }
    984. 

  984. 	    }
    985. 

  985.   	  }
    986. 

  986. 	  if (!wasproject) {
    987. 

  987. 	    if (lastproject == k && r == 0.0)
    988. 

  988. 	      lastproject= -1;  /* doesn't catch all possible sequences */
    989. 

  989. 	    else if (key == 'b') {
    990. 

  990. 	      qh SCALEinput= True;
    991. 

  991. 	      if (r == 0.0)
    992. 

  992. 		r= -qh_DEFAULTbox;
    993. 

  993. 	      qh_option ("Qbound-dim-low", &k, &r);
    994. 

  994. 	    }else {
    995. 

  995. 	      qh SCALEinput= True;
    996. 

  996. 	      if (r == 0.0)
    997. 

  997. 		r= qh_DEFAULTbox;
    998. 

  998. 	      qh_option ("QBound-dim-high", &k, &r);
    999. 

  999. 	    }
    1000. 

  1000. 	  }
    1001. 

  1001. 	  break;
    1002. 

  1002. 	case 'c':
    1003. 

  1003. 	  qh_option ("Qcoplanar-keep", NULL, NULL);
    1004. 

  1004. 	  qh KEEPcoplanar= True;
    1005. 

  1005. 	  break;
    1006. 

  1006. 	case 'f':
    1007. 

  1007. 	  qh_option ("Qfurthest-outside", NULL, NULL);
    1008. 

  1008. 	  qh BESToutside= True;
    1009. 

  1009. 	  break;
    1010. 

  1010. 	case 'g':
    1011. 

  1011. 	  qh_option ("Qgood-facets-only", NULL, NULL);
    1012. 

  1012. 	  qh ONLYgood= True;
    1013. 

  1013. 	  break;
    1014. 

  1014. 	case 'i':
    1015. 

  1015. 	  qh_option ("Qinterior-keep", NULL, NULL);
    1016. 

  1016. 	  qh KEEPinside= True;
    1017. 

  1017. 	  break;
    1018. 

  1018. 	case 'm':
    1019. 

  1019. 	  qh_option ("Qmax-outside-only", NULL, NULL);
    1020. 

  1020. 	  qh ONLYmax= True;
    1021. 

  1021. 	  break;
    1022. 

  1022. 	case 'r':
    1023. 

  1023. 	  qh_option ("Qrandom-outside", NULL, NULL);
    1024. 

  1024. 	  qh RANDOMoutside= True;
    1025. 

  1025. 	  break;
    1026. 

  1026. 	case 's':
    1027. 

  1027. 	  qh_option ("Qsearch-initial-simplex", NULL, NULL);
    1028. 

  1028. 	  qh ALLpoints= True;
    1029. 

  1029. 	  break;
    1030. 

  1030. 	case 't':
    1031. 

  1031. 	  qh_option ("Qtriangulate", NULL, NULL);
    1032. 

  1032. 	  qh TRIangulate= True;
    1033. 

  1033. 	  break;
    1034. 

  1034. 	case 'T':
    1035. 

  1035. 	  qh_option ("QTestPoints", NULL, NULL);
    1036. 

  1036. 	  if (!isdigit (*s))
    1037. 

  1037. 	    fprintf (qh ferr, "qhull input error: missing number of test points for option 'QTn'\n");
    1038. 

  1038. 	  else {
    1039. 

  1039.   	    qh TESTpoints= qh_strtol (s, &s);
    1040. 

  1040.             qh_option ("QTestPoints", &qh TESTpoints, NULL);
    1041. 

  1041.           }
    1042. 

  1042. 	  break;
    1043. 

  1043. 	case 'u':
    1044. 

  1044. 	  qh_option ("QupperDelaunay", NULL, NULL);
    1045. 

  1045. 	  qh UPPERdelaunay= True;
    1046. 

  1046. 	  break;
    1047. 

  1047. 	case 'v':
    1048. 

  1048. 	  qh_option ("Qvertex-neighbors-convex", NULL, NULL);
    1049. 

  1049. 	  qh TESTvneighbors= True;
    1050. 

  1050. 	  break;
    1051. 

  1051. 	case 'x':
    1052. 

  1052. 	  qh_option ("Qxact-merge", NULL, NULL);
    1053. 

  1053. 	  qh MERGEexact= True;
    1054. 

  1054. 	  break;
    1055. 

  1055. 	case 'z':
    1056. 

  1056. 	  qh_option ("Qz-infinity-point", NULL, NULL);
    1057. 

  1057. 	  qh ATinfinity= True;
    1058. 

  1058. 	  break;
    1059. 

  1059. 	case '0':
    1060. 

  1060. 	  qh_option ("Q0-no-premerge", NULL, NULL);
    1061. 

  1061. 	  qh NOpremerge= True;
    1062. 

  1062. 	  break;
    1063. 

  1063. 	case '1':
    1064. 

  1064. 	  if (!isdigit(*s)) {
    1065. 

  1065. 	    qh_option ("Q1-no-angle-sort", NULL, NULL);
    1066. 

  1066. 	    qh ANGLEmerge= False;
    1067. 

  1067. 	    break; 
    1068. 

  1068. 	  }
    1069. 

  1069. 	  switch(*s++) {
    1070. 

  1070.   	  case '0':
    1071. 

  1071. 	    qh_option ("Q10-no-narrow", NULL, NULL);
    1072. 

  1072. 	    qh NOnarrow= True;
    1073. 

  1073. 	    break; 
    1074. 

  1074.   	  case '1':
    1075. 

  1075. 	    qh_option ("Q11-trinormals Qtriangulate", NULL, NULL);
    1076. 

  1076. 	    qh TRInormals= True;
    1077. 

  1077. 	    qh TRIangulate= True;
    1078. 

  1078. 	    break; 
    1079. 

  1079. 	  default:
    1080. 

  1080. 	    s--;
    1081. 

  1081. 	    fprintf (qh ferr, "qhull warning: unknown 'Q' qhull option 1%c, rest ignored\n", (int)s[0]);
    1082. 

  1082. 	    while (*++s && !isspace(*s));
    1083. 

  1083. 	    break;
    1084. 

  1084. 	  }
    1085. 

  1085. 	  break;
    1086. 

  1086. 	case '2':
    1087. 

  1087. 	  qh_option ("Q2-no-merge-independent", NULL, NULL);
    1088. 

  1088. 	  qh MERGEindependent= False;
    1089. 

  1089. 	  goto LABELcheckdigit;
    1090. 

  1090. 	  break; /* no warnings */
    1091. 

  1091. 	case '3':
    1092. 

  1092. 	  qh_option ("Q3-no-merge-vertices", NULL, NULL);
    1093. 

  1093. 	  qh MERGEvertices= False;
    1094. 

  1094. 	LABELcheckdigit:
    1095. 

  1095. 	  if (isdigit(*s))
    1096. 

  1096. 	    fprintf (qh ferr, "qhull warning: can not follow '1', '2', or '3' with a digit.  '%c' skipped.\n",
    1097. 

  1097. 	             *s++);
    1098. 

  1098. 	  break;
    1099. 

  1099. 	case '4':
    1100. 

  1100. 	  qh_option ("Q4-avoid-old-into-new", NULL, NULL);
    1101. 

  1101. 	  qh AVOIDold= True;
    1102. 

  1102. 	  break;
    1103. 

  1103. 	case '5':
    1104. 

  1104. 	  qh_option ("Q5-no-check-outer", NULL, NULL);
    1105. 

  1105. 	  qh SKIPcheckmax= True;
    1106. 

  1106. 	  break;
    1107. 

  1107. 	case '6':
    1108. 

  1108. 	  qh_option ("Q6-no-concave-merge", NULL, NULL);
    1109. 

  1109. 	  qh SKIPconvex= True;
    1110. 

  1110. 	  break;
    1111. 

  1111. 	case '7':
    1112. 

  1112. 	  qh_option ("Q7-no-breadth-first", NULL, NULL);
    1113. 

  1113. 	  qh VIRTUALmemory= True;
    1114. 

  1114. 	  break;
    1115. 

  1115. 	case '8':
    1116. 

  1116. 	  qh_option ("Q8-no-near-inside", NULL, NULL);
    1117. 

  1117. 	  qh NOnearinside= True;
    1118. 

  1118. 	  break;
    1119. 

  1119. 	case '9':
    1120. 

  1120. 	  qh_option ("Q9-pick-furthest", NULL, NULL);
    1121. 

  1121. 	  qh PICKfurthest= True;
    1122. 

  1122. 	  break;
    1123. 

  1123. 	case 'G':
    1124. 

  1124. 	  i= qh_strtol (s, &t);
    1125. 

  1125. 	  if (qh GOODpoint)
    1126. 

  1126. 	    fprintf (qh ferr, "qhull warning: good point already defined for option 'QGn'.  Ignored\n");
    1127. 

  1127.           else if (s == t)
    1128. 

  1128. 	    fprintf (qh ferr, "qhull warning: missing good point id for option 'QGn'.  Ignored\n");
    1129. 

  1129. 	  else if (i < 0 || *s == '-') {
    1130. 

  1130.  	    qh GOODpoint= i-1;
    1131. 

  1131.   	    qh_option ("QGood-if-dont-see-point", &i, NULL);
    1132. 

  1132. 	  }else {
    1133. 

  1133.  	    qh GOODpoint= i+1;
    1134. 

  1134.   	    qh_option ("QGood-if-see-point", &i, NULL);
    1135. 

  1135.   	  }
    1136. 

  1136.  	  s= t;
    1137. 

  1137. 	  break;
    1138. 

  1138. 	case 'J':
    1139. 

  1139.           if (!isdigit(*s) && *s != '-')
    1140. 

  1140.    	    qh JOGGLEmax= 0.0;
    1141. 

  1141. 	  else {
    1142. 

  1142.  	    qh JOGGLEmax= (realT) qh_strtod (s, &s);
    1143. 

  1143.             qh_option ("QJoggle", NULL, &qh JOGGLEmax);
    1144. 

  1144. 	  }
    1145. 

  1145. 	  break;
    1146. 

  1146. 	case 'R':
    1147. 

  1147.           if (!isdigit(*s) && *s != '-')
    1148. 

  1148. 	    fprintf (qh ferr, "qhull warning: missing random seed for option 'QRn'.  Ignored\n");
    1149. 

  1149. 	  else {
    1150. 

  1150.  	    qh ROTATErandom= i= qh_strtol(s, &s);
    1151. 

  1151.    	    if (i > 0)
    1152. 

  1152.    	      qh_option ("QRotate-id", &i, NULL );
    1153. 

  1153. 	    else if (i < -1)
    1154. 

  1154.    	      qh_option ("QRandom-seed", &i, NULL );
    1155. 

  1155.           }
    1156. 

  1156. 	  break;
    1157. 

  1157. 	case 'V':
    1158. 

  1158. 	  i= qh_strtol (s, &t);
    1159. 

  1159. 	  if (qh GOODvertex)
    1160. 

  1160. 	    fprintf (qh ferr, "qhull warning: good vertex already defined for option 'QVn'.  Ignored\n");
    1161. 

  1161.           else if (s == t)
    1162. 

  1162. 	    fprintf (qh ferr, "qhull warning: no good point id given for option 'QVn'.  Ignored\n");
    1163. 

  1163. 	  else if (i < 0) {
    1164. 

  1164.  	    qh GOODvertex= i - 1;
    1165. 

  1165.  	    qh_option ("QV-good-facets-not-point", &i, NULL);
    1166. 

  1166. 	  }else {
    1167. 

  1167.   	    qh_option ("QV-good-facets-point", &i, NULL);
    1168. 

  1168. 	    qh GOODvertex= i + 1;
    1169. 

  1169.           }
    1170. 

  1170.  	  s= t;
    1171. 

  1171. 	  break;
    1172. 

  1172. 	default:
    1173. 

  1173. 	  s--;
    1174. 

  1174. 	  fprintf (qh ferr, "qhull warning: unknown 'Q' qhull option %c, rest ignored\n", (int)s[0]);
    1175. 

  1175. 	  while (*++s && !isspace(*s));
    1176. 

  1176. 	  break;
    1177. 

  1177. 	}
    1178. 

  1178.       }
    1179. 

  1179.       break;
    1180. 

  1180.     case 'T':
    1181. 

  1181.       while (*s && !isspace(*s)) {
    1182. 

  1182. 	if (isdigit(*s) || *s == '-')
    1183. 

  1183. 	  qh IStracing= qh_strtol(s, &s);
    1184. 

  1184. 	else switch(*s++) {
    1185. 

  1185. 	case 'c':
    1186. 

  1186.           qh_option ("Tcheck-frequently", NULL, NULL);
    1187. 

  1187. 	  qh CHECKfrequently= True;
    1188. 

  1188. 	  break;
    1189. 

  1189. 	case 's':
    1190. 

  1190.           qh_option ("Tstatistics", NULL, NULL);
    1191. 

  1191. 	  qh PRINTstatistics= True;
    1192. 

  1192. 	  break;
    1193. 

  1193. 	case 'v':
    1194. 

  1194.           qh_option ("Tverify", NULL, NULL);
    1195. 

  1195. 	  qh VERIFYoutput= True;
    1196. 

  1196. 	  break;
    1197. 

  1197. 	case 'z':
    1198. 

  1198. 	  if (!qh fout)
    1199. 

  1199. 	    fprintf (qh ferr, "qhull warning: output file undefined (stdout).  Option 'Tz' ignored.\n");
    1200. 

  1200. 	  else {
    1201. 

  1201. 	    qh_option ("Tz-stdout", NULL, NULL);
    1202. 

  1202.   	    qh ferr= qh fout;
    1203. 

  1203.   	    qhmem.ferr= qh fout;
    1204. 

  1204. 	  }
    1205. 

  1205. 	  break;
    1206. 

  1206. 	case 'C':
    1207. 

  1207. 	  if (!isdigit(*s))
    1208. 

  1208. 	    fprintf (qh ferr, "qhull warning: missing point id for cone for trace option 'TCn'.  Ignored\n");
    1209. 

  1209. 	  else {
    1210. 

  1210. 	    i= qh_strtol (s, &s);
    1211. 

  1211. 	    qh_option ("TCone-stop", &i, NULL);
    1212. 

  1212. 	    qh STOPcone= i + 1;
    1213. 

  1213.           }
    1214. 

  1214. 	  break;
    1215. 

  1215. 	case 'F':
    1216. 

  1216. 	  if (!isdigit(*s))
    1217. 

  1217. 	    fprintf (qh ferr, "qhull warning: missing frequency count for trace option 'TFn'.  Ignored\n");
    1218. 

  1218. 	  else {
    1219. 

  1219. 	    qh REPORTfreq= qh_strtol (s, &s);
    1220. 

  1220.             qh_option ("TFacet-log", &qh REPORTfreq, NULL);
    1221. 

  1221. 	    qh REPORTfreq2= qh REPORTfreq/2;  /* for tracemerging() */
    1222. 

  1222. 	  }
    1223. 

  1223. 	  break;
    1224. 

  1224. 	case 'I':
    1225. 

  1225. 	  if (s[0] != ' ' || s[1] == '\"' || s[1] == '\'' ||isspace (s[1])) {
    1226. 

  1226. 	    s++;
    1227. 

  1227. 	    fprintf (qh ferr, "qhull warning: option 'TI' mistyped.\nUse 'TI', one space, file name, and space or end-of-line.\nDo not use quotes.  Option 'FI' ignored.\n");
    1228. 

  1228. 	  }else {  /* not a procedure because of qh_option (filename, NULL, NULL); */
    1229. 

  1229. 	    char filename[500], *t= filename;
    1230. 

  1230. 

  1231. 	    s++;
    1232. 

  1232. 	    while (*s) {
    1233. 

  1233. 	      if (t - filename >= sizeof (filename)-2) {
    1234. 

  1234. 		fprintf (qh ferr, "qhull error: filename for 'TI' too long.\n");
    1235. 

  1235. 		qh_errexit (qh_ERRinput, NULL, NULL);
    1236. 

  1236. 	      }
    1237. 

  1237. 	      if (isspace (*s))
    1238. 

  1238. 		break;
    1239. 

  1239. 	      *(t++)= *s++;
    1240. 

  1240. 	    }
    1241. 

  1241. 	    *t= '\0';
    1242. 

  1242. 	    if (!freopen (filename, "r", stdin)) {
    1243. 

  1243. 	      fprintf (qh ferr, "qhull error: could not open file \"%s\".", filename);
    1244. 

  1244. 	      qh_errexit (qh_ERRinput, NULL, NULL);
    1245. 

  1245. 	    }else {
    1246. 

  1246. 	      qh_option ("TInput-file", NULL, NULL);
    1247. 

  1247. 	      qh_option (filename, NULL, NULL);
    1248. 

  1248. 	    }
    1249. 

  1249. 	  }
    1250. 

  1250. 	  break;
    1251. 

  1251. 	case 'O':
    1252. 

  1252. 	  if (s[0] != ' ' || s[1] == '\"' || isspace (s[1])) {
    1253. 

  1253. 	    s++;
    1254. 

  1254. 	    fprintf (qh ferr, "qhull warning: option 'TO' mistyped.\nUse 'TO', one space, file name, and space or end-of-line.\nThe file name may be enclosed in single quotes.\nDo not use double quotes.  Option 'FO' ignored.\n");
    1255. 

  1255. 	  }else {  /* not a procedure because of qh_option (filename, NULL, NULL); */
    1256. 

  1256. 	    char filename[500], *t= filename;
    1257. 

  1257. 	    boolT isquote= False;
    1258. 

  1258. 

  1259. 	    s++;
    1260. 

  1260. 	    if (*s == '\'') {
    1261. 

  1261. 	      isquote= True;
    1262. 

  1262. 	      s++;
    1263. 

  1263. 	    }
    1264. 

  1264. 	    while (*s) {
    1265. 

  1265. 	      if (t - filename >= sizeof (filename)-2) {
    1266. 

  1266. 		fprintf (qh ferr, "qhull error: filename for 'TO' too long.\n");
    1267. 

  1267. 		qh_errexit (qh_ERRinput, NULL, NULL);
    1268. 

  1268. 	      }
    1269. 

  1269. 	      if (isquote) {
    1270. 

  1270. 		if (*s == '\'') {
    1271. 

  1271. 		  s++;
    1272. 

  1272. 		  isquote= False;
    1273. 

  1273. 		  break;
    1274. 

  1274. 		}
    1275. 

  1275. 	      }else if (isspace (*s))
    1276. 

  1276. 		break;
    1277. 

  1277. 	      *(t++)= *s++;
    1278. 

  1278. 	    }
    1279. 

  1279. 	    *t= '\0';
    1280. 

  1280. 	    if (isquote)
    1281. 

  1281. 	      fprintf (qh ferr, "qhull error: missing end quote for option 'TO'.  Rest of line ignored.\n");
    1282. 

  1282. 	    else if (!freopen (filename, "w", stdout)) {
    1283. 

  1283. 	      fprintf (qh ferr, "qhull error: could not open file \"%s\".", filename);
    1284. 

  1284. 	      qh_errexit (qh_ERRinput, NULL, NULL);
    1285. 

  1285. 	    }else {
    1286. 

  1286. 	      qh_option ("TOutput-file", NULL, NULL);
    1287. 

  1287. 	      qh_option (filename, NULL, NULL);
    1288. 

  1288. 	    }
    1289. 

  1289. 	  }
    1290. 

  1290. 	  break;
    1291. 

  1291. 	case 'P':
    1292. 

  1292. 	  if (!isdigit(*s))
    1293. 

  1293. 	    fprintf (qh ferr, "qhull warning: missing point id for trace option 'TPn'.  Ignored\n");
    1294. 

  1294. 	  else {
    1295. 

  1295. 	    qh TRACEpoint= qh_strtol (s, &s);
    1296. 

  1296.             qh_option ("Trace-point", &qh TRACEpoint, NULL);
    1297. 

  1297.           }
    1298. 

  1298. 	  break;
    1299. 

  1299. 	case 'M':
    1300. 

  1300. 	  if (!isdigit(*s))
    1301. 

  1301. 	    fprintf (qh ferr, "qhull warning: missing merge id for trace option 'TMn'.  Ignored\n");
    1302. 

  1302. 	  else {
    1303. 

  1303. 	    qh TRACEmerge= qh_strtol (s, &s);
    1304. 

  1304.             qh_option ("Trace-merge", &qh TRACEmerge, NULL);
    1305. 

  1305.           }
    1306. 

  1306. 	  break;
    1307. 

  1307. 	case 'R':
    1308. 

  1308. 	  if (!isdigit(*s))
    1309. 

  1309. 	    fprintf (qh ferr, "qhull warning: missing rerun count for trace option 'TRn'.  Ignored\n");
    1310. 

  1310. 	  else {
    1311. 

  1311. 	    qh RERUN= qh_strtol (s, &s);
    1312. 

  1312.             qh_option ("TRerun", &qh RERUN, NULL);
    1313. 

  1313.           }
    1314. 

  1314. 	  break;
    1315. 

  1315. 	case 'V':
    1316. 

  1316. 	  i= qh_strtol (s, &t);
    1317. 

  1317. 	  if (s == t)
    1318. 

  1318. 	    fprintf (qh ferr, "qhull warning: missing furthest point id for trace option 'TVn'.  Ignored\n");
    1319. 

  1319. 	  else if (i < 0) {
    1320. 

  1320. 	    qh STOPpoint= i - 1;
    1321. 

  1321.             qh_option ("TV-stop-before-point", &i, NULL);
    1322. 

  1322. 	  }else {
    1323. 

  1323. 	    qh STOPpoint= i + 1;
    1324. 

  1324.             qh_option ("TV-stop-after-point", &i, NULL);
    1325. 

  1325.           }
    1326. 

  1326.           s= t;
    1327. 

  1327. 	  break;
    1328. 

  1328. 	case 'W':
    1329. 

  1329. 	  if (!isdigit(*s))
    1330. 

  1330. 	    fprintf (qh ferr, "qhull warning: missing max width for trace option 'TWn'.  Ignored\n");
    1331. 

  1331. 	  else {
    1332. 

  1332.  	    qh TRACEdist= (realT) qh_strtod (s, &s);
    1333. 

  1333.             qh_option ("TWide-trace", NULL, &qh TRACEdist);
    1334. 

  1334.           }
    1335. 

  1335. 	  break;
    1336. 

  1336. 	default:
    1337. 

  1337. 	  s--;
    1338. 

  1338. 	  fprintf (qh ferr, "qhull warning: unknown 'T' trace option %c, rest ignored\n", (int)s[0]);
    1339. 

  1339. 	  while (*++s && !isspace(*s));
    1340. 

  1340. 	  break;
    1341. 

  1341. 	}
    1342. 

  1342.       }
    1343. 

  1343.       break;
    1344. 

  1344.     default:
    1345. 

  1345.       fprintf (qh ferr, "qhull warning: unknown flag %c (%x)\n", (int)s[-1],
    1346. 

  1346. 	       (int)s[-1]);
    1347. 

  1347.       break;
    1348. 

  1348.     }
    1349. 

  1349.     if (s-1 == prev_s && *s && !isspace(*s)) {
    1350. 

  1350.       fprintf (qh ferr, "qhull warning: missing space after flag %c (%x); reserved for menu. Skipped.\n",
    1351. 

  1351. 	       (int)*prev_s, (int)*prev_s);
    1352. 

  1352.       while (*s && !isspace(*s))
    1353. 

  1353. 	s++;
    1354. 

  1354.     }
    1355. 

  1355.   }
    1356. 

  1356.   if (isgeom && !qh FORCEoutput && qh PRINTout[1])
    1357. 

  1357.     fprintf (qh ferr, "qhull warning: additional output formats are not compatible with Geomview\n");
    1358. 

  1358.   /* set derived values in qh_initqhull_globals */
    1359. 

  1359. } /* initflags */
    1360. 

  1360. 

  1361. 

  1362. /*-<a                             href="qh-globa.htm#TOC"
    1363. 

  1363.   >-------------------------------</a><a name="initqhull_buffers">-</a>
    1364. 

    1365. 

  1365.   qh_initqhull_buffers()
    1366. 

  1366.     initialize global memory buffers
    1367. 

    1368. 

  1368.   notes:
    1369. 

  1369.     must match qh_freebuffers()
    1370. 

  1370. */
    1371. 

  1371. void qh_initqhull_buffers (void) {
    1372. 

  1372.   int k;
    1373. 

  1373. 

  1374.   qh TEMPsize= (qhmem.LASTsize - sizeof (setT))/SETelemsize;
    1375. 

  1375.   if (qh TEMPsize <= 0 || qh TEMPsize > qhmem.LASTsize)
    1376. 

  1376.     qh TEMPsize= 8;  /* e.g., if qh_NOmem */
    1377. 

  1377.   qh other_points= qh_setnew (qh TEMPsize);
    1378. 

  1378.   qh del_vertices= qh_setnew (qh TEMPsize);
    1379. 

  1379.   qh coplanarset= qh_setnew (qh TEMPsize);
    1380. 

  1380.   qh NEARzero= (realT *)qh_memalloc(qh hull_dim * sizeof(realT));
    1381. 

  1381.   qh lower_threshold= (realT *)qh_memalloc((qh input_dim+1) * sizeof(realT));
    1382. 

  1382.   qh upper_threshold= (realT *)qh_memalloc((qh input_dim+1) * sizeof(realT));
    1383. 

  1383.   qh lower_bound= (realT *)qh_memalloc((qh input_dim+1) * sizeof(realT));
    1384. 

  1384.   qh upper_bound= (realT *)qh_memalloc((qh input_dim+1) * sizeof(realT));
    1385. 

  1385.   for(k= qh input_dim+1; k--; ) {
    1386. 

  1386.     qh lower_threshold[k]= -REALmax;
    1387. 

  1387.     qh upper_threshold[k]= REALmax;
    1388. 

  1388.     qh lower_bound[k]= -REALmax;
    1389. 

  1389.     qh upper_bound[k]= REALmax;
    1390. 

  1390.   }
    1391. 

  1391.   qh gm_matrix= (coordT *)qh_memalloc((qh hull_dim+1) * qh hull_dim * sizeof(coordT));
    1392. 

  1392.   qh gm_row= (coordT **)qh_memalloc((qh hull_dim+1) * sizeof(coordT *));
    1393. 

  1393. } /* initqhull_buffers */
    1394. 

  1394. 

  1395. /*-<a                             href="qh-globa.htm#TOC"
    1396. 

  1396.   >-------------------------------</a><a name="initqhull_globals">-</a>
    1397. 

    1398. 

  1398.   qh_initqhull_globals( points, numpoints, dim, ismalloc )
    1399. 

  1399.     initialize globals
    1400. 

  1400.     if ismalloc
    1401. 

  1401.       points were malloc'd and qhull should free at end
    1402. 

    1403. 

  1403.   returns:
    1404. 

  1404.     sets qh.first_point, num_points, input_dim, hull_dim and others
    1405. 

  1405.     seeds random number generator (seed=1 if tracing)
    1406. 

  1406.     modifies qh.hull_dim if ((qh.DELAUNAY and qh.PROJECTdelaunay) or qh.PROJECTinput)
    1407. 

  1407.     adjust user flags as needed
    1408. 

  1408.     also checks DIM3 dependencies and constants
    1409. 

    1410. 

  1410.   notes:
    1411. 

  1411.     do not use qh_point() since an input transformation may move them elsewhere
    1412. 

    1413. 

  1413.   see:
    1414. 

  1414.     qh_initqhull_start() sets default values for non-zero globals
    1415. 

    1416. 

  1416.   design:
    1417. 

  1417.     initialize points array from input arguments
    1418. 

  1418.     test for qh.ZEROcentrum
    1419. 

  1419.       (i.e., use opposite vertex instead of cetrum for convexity testing)
    1420. 

  1420.     test for qh.PRINTgood (i.e., only print 'good' facets)
    1421. 

  1421.     initialize qh.CENTERtype, qh.normal_size,
    1422. 

  1422.       qh.center_size, qh.TRACEpoint/level,
    1423. 

  1423.     initialize and test random numbers
    1424. 

  1424.     check for conflicting print output options
    1425. 

  1425. */
    1426. 

  1426. void qh_initqhull_globals (coordT *points, int numpoints, int dim, boolT ismalloc) {
    1427. 

  1427.   int seed, pointsneeded, extra= 0, i, randi, k;
    1428. 

  1428.   boolT printgeom= False, printmath= False, printcoplanar= False;
    1429. 

  1429.   realT randr;
    1430. 

  1430.   realT factorial;
    1431. 

  1431. 

  1432.   time_t timedata;
    1433. 

  1433. 

  1434.   trace0((qh ferr, "qh_initqhull_globals: for %s | %s\n", qh rbox_command,
    1435. 

  1435.       qh qhull_command));
    1436. 

  1436.   qh POINTSmalloc= ismalloc;
    1437. 

  1437.   qh first_point= points;
    1438. 

  1438.   qh num_points= numpoints;
    1439. 

  1439.   qh hull_dim= qh input_dim= dim;
    1440. 

  1440.   if (!qh NOpremerge && !qh MERGEexact && !qh PREmerge && qh JOGGLEmax > REALmax/2) {
    1441. 

  1441.     qh MERGING= True;
    1442. 

  1442.     if (qh hull_dim <= 4) {
    1443. 

  1443.       qh PREmerge= True;
    1444. 

  1444.       qh_option ("_pre-merge", NULL, NULL);
    1445. 

  1445.     }else {
    1446. 

  1446.       qh MERGEexact= True;
    1447. 

  1447.       qh_option ("Qxact_merge", NULL, NULL);
    1448. 

  1448.     }
    1449. 

  1449.   }else if (qh MERGEexact) 
    1450. 

  1450.     qh MERGING= True;
    1451. 

  1451.   if (!qh NOpremerge && qh JOGGLEmax > REALmax/2) {
    1452. 

  1452. #ifdef qh_NOmerge
    1453. 

  1453.     qh JOGGLEmax= 0.0;
    1454. 

  1454. #endif
    1455. 

  1455.   }
    1456. 

  1456.   if (qh TRIangulate && qh JOGGLEmax < REALmax/2 && qh PRINTprecision)
    1457. 

  1457.     fprintf(qh ferr, "qhull warning: joggle ('QJ') always produces simplicial output.  Triangulated output ('Qt') does nothing.\n");
    1458. 

  1458.   if (qh JOGGLEmax < REALmax/2 && qh DELAUNAY && !qh SCALEinput && !qh SCALElast) {
    1459. 

  1459.     qh SCALElast= True;
    1460. 

  1460.     qh_option ("Qbbound-last-qj", NULL, NULL);
    1461. 

  1461.   }
    1462. 

  1462.   if (qh MERGING && !qh POSTmerge && qh premerge_cos > REALmax/2
    1463. 

  1463.   && qh premerge_centrum == 0) {
    1464. 

  1464.     qh ZEROcentrum= True;
    1465. 

  1465.     qh ZEROall_ok= True;
    1466. 

  1466.     qh_option ("_zero-centrum", NULL, NULL);
    1467. 

  1467.   }
    1468. 

  1468.   if (qh JOGGLEmax < REALmax/2 && REALepsilon > 2e-8 && qh PRINTprecision)
    1469. 

  1469.     fprintf(qh ferr, "qhull warning: real epsilon, %2.2g, is probably too large for joggle ('QJn')\nRecompile with double precision reals (see user.h).\n",
    1470. 

  1470.           REALepsilon);
    1471. 

  1471. #ifdef qh_NOmerge
    1472. 

  1472.   if (qh MERGING) {
    1473. 

  1473.     fprintf (qh ferr, "qhull input error: merging not installed (qh_NOmerge + 'Qx', 'Cn' or 'An')\n");
    1474. 

  1474.     qh_errexit (qh_ERRinput, NULL, NULL);
    1475. 

  1475.   }
    1476. 

  1476. #endif
    1477. 

  1477.   if (!(qh PRINTgood || qh PRINTneighbors)) {
    1478. 

  1478.     if (qh KEEParea || qh KEEPminArea < REALmax/2 || qh KEEPmerge || qh DELAUNAY
    1479. 

  1479. 	|| (!qh ONLYgood && (qh GOODvertex || qh GOODpoint))) {
    1480. 

  1480.       qh PRINTgood= True;
    1481. 

  1481.       qh_option ("Pgood", NULL, NULL);
    1482. 

  1482.     }
    1483. 

  1483.   }
    1484. 

  1484.   if (qh DELAUNAY && qh KEEPcoplanar && !qh KEEPinside) {
    1485. 

  1485.     qh KEEPinside= True;
    1486. 

  1486.     qh_option ("Qinterior-keep", NULL, NULL);
    1487. 

  1487.   }
    1488. 

  1488.   if (qh DELAUNAY && qh HALFspace) {
    1489. 

  1489.     fprintf (qh ferr, "qhull input error: can not use Delaunay ('d') or Voronoi ('v') with halfspace intersection ('H')\n");
    1490. 

  1490.     qh_errexit (qh_ERRinput, NULL, NULL);
    1491. 

  1491.   }
    1492. 

  1492.   if (!qh DELAUNAY && (qh UPPERdelaunay || qh ATinfinity)) {
    1493. 

  1493.     fprintf (qh ferr, "qhull input error: use upper-Delaunay ('Qu') or infinity-point ('Qz') with Delaunay ('d') or Voronoi ('v')\n");
    1494. 

  1494.     qh_errexit (qh_ERRinput, NULL, NULL);
    1495. 

  1495.   }
    1496. 

  1496.   if (qh UPPERdelaunay && qh ATinfinity) {
    1497. 

  1497.     fprintf (qh ferr, "qhull input error: can not use infinity-point ('Qz') with upper-Delaunay ('Qu')\n");
    1498. 

  1498.     qh_errexit (qh_ERRinput, NULL, NULL);
    1499. 

  1499.   }
    1500. 

  1500.   if (qh SCALElast && !qh DELAUNAY && qh PRINTprecision)
    1501. 

  1501.     fprintf (qh ferr, "qhull input warning: option 'Qbb' (scale-last-coordinate) is normally used with 'd' or 'v'\n");
    1502. 

  1502.   qh DOcheckmax= (!qh SKIPcheckmax && qh MERGING );
    1503. 

  1503.   qh KEEPnearinside= (qh DOcheckmax && !(qh KEEPinside && qh KEEPcoplanar) 
    1504. 

  1504.                           && !qh NOnearinside);
    1505. 

  1505.   if (qh MERGING)
    1506. 

  1506.     qh CENTERtype= qh_AScentrum;
    1507. 

  1507.   else if (qh VORONOI)
    1508. 

  1508.     qh CENTERtype= qh_ASvoronoi;
    1509. 

  1509.   if (qh TESTvneighbors && !qh MERGING) {
    1510. 

  1510.     fprintf(qh ferr, "qhull input error: test vertex neighbors ('Qv') needs a merge option\n");
    1511. 

  1511.     qh_errexit (qh_ERRinput, NULL ,NULL);
    1512. 

  1512.   }
    1513. 

  1513.   if (qh PROJECTinput || (qh DELAUNAY && qh PROJECTdelaunay)) {
    1514. 

  1514.     qh hull_dim -= qh PROJECTinput;
    1515. 

  1515.     if (qh DELAUNAY) {
    1516. 

  1516.       qh hull_dim++;
    1517. 

  1517.       extra= 1;
    1518. 

  1518.     }
    1519. 

  1519.   }
    1520. 

  1520.   if (qh hull_dim <= 1) {
    1521. 

  1521.     fprintf(qh ferr, "qhull error: dimension %d must be > 1\n", qh hull_dim);
    1522. 

  1522.     qh_errexit (qh_ERRinput, NULL, NULL);
    1523. 

  1523.   }
    1524. 

  1524.   for (k= 2, factorial=1.0; k < qh hull_dim; k++)
    1525. 

  1525.     factorial *= k;
    1526. 

  1526.   qh AREAfactor= 1.0 / factorial;
    1527. 

  1527.   trace2((qh ferr, "qh_initqhull_globals: initialize globals.  dim %d numpoints %d malloc? %d projected %d to hull_dim %d\n",
    1528. 

  1528. 	dim, numpoints, ismalloc, qh PROJECTinput, qh hull_dim));
    1529. 

  1529.   qh normal_size= qh hull_dim * sizeof(coordT);
    1530. 

  1530.   qh center_size= qh normal_size - sizeof(coordT);
    1531. 

  1531.   pointsneeded= qh hull_dim+1;
    1532. 

  1532.   if (qh hull_dim > qh_DIMmergeVertex) {
    1533. 

  1533.     qh MERGEvertices= False;
    1534. 

  1534.     qh_option ("Q3-no-merge-vertices-dim-high", NULL, NULL);
    1535. 

  1535.   }
    1536. 

  1536.   if (qh GOODpoint)
    1537. 

  1537.     pointsneeded++;
    1538. 

  1538. #ifdef qh_NOtrace
    1539. 

  1539.   if (qh IStracing) {
    1540. 

  1540.     fprintf (qh ferr, "qhull input error: tracing is not installed (qh_NOtrace in user.h)");
    1541. 

  1541.     qh_errexit (qh_ERRqhull, NULL, NULL);
    1542. 

  1542.   }
    1543. 

  1543. #endif
    1544. 

  1544.   if (qh RERUN > 1) {
    1545. 

  1545.     qh TRACElastrun= qh IStracing; /* qh_build_withrestart duplicates next conditional */
    1546. 

  1546.     if (qh IStracing != -1)
    1547. 

  1547.       qh IStracing= 0;
    1548. 

  1548.   }else if (qh TRACEpoint != -1 || qh TRACEdist < REALmax/2 || qh TRACEmerge) {
    1549. 

  1549.     qh TRACElevel= (qh IStracing? qh IStracing : 3);
    1550. 

  1550.     qh IStracing= 0;
    1551. 

  1551.   }
    1552. 

  1552.   if (qh ROTATErandom == 0 || qh ROTATErandom == -1) {
    1553. 

  1553.     seed= time (&timedata);
    1554. 

  1554.     if (qh ROTATErandom  == -1) {
    1555. 

  1555.       seed= -seed;
    1556. 

  1556.       qh_option ("QRandom-seed", &seed, NULL );
    1557. 

  1557.     }else
    1558. 

  1558.       qh_option ("QRotate-random", &seed, NULL);
    1559. 

  1559.     qh ROTATErandom= seed;
    1560. 

  1560.   }
    1561. 

  1561.   seed= qh ROTATErandom;
    1562. 

  1562.   if (seed == INT_MIN)    /* default value */
    1563. 

  1563.     seed= 1;
    1564. 

  1564.   else if (seed < 0)
    1565. 

  1565.     seed= -seed;
    1566. 

  1566.   qh_RANDOMseed_(seed);
    1567. 

  1567.   randr= 0.0;
    1568. 

  1568.   for (i= 1000; i--; ) {
    1569. 

  1569.     randi= qh_RANDOMint;
    1570. 

  1570.     randr += randi;
    1571. 

  1571.     if (randi > qh_RANDOMmax) {
    1572. 

  1572.       fprintf (qh ferr, "\
    1573. 

  1573. qhull configuration error (qh_RANDOMmax in user.h):\n\
    1574. 

  1574.    random integer %d > qh_RANDOMmax (%.8g)\n",
    1575. 

  1575. 	       randi, qh_RANDOMmax);
    1576. 

  1576.       qh_errexit (qh_ERRinput, NULL, NULL);
    1577. 

  1577.     }
    1578. 

  1578.   }
    1579. 

  1579.   qh_RANDOMseed_(seed);
    1580. 

  1580.   randr = randr/1000;
    1581. 

  1581.   if (randr < qh_RANDOMmax/10
    1582. 

  1582.   || randr > qh_RANDOMmax * 5)
    1583. 

  1583.     fprintf (qh ferr, "\
    1584. 

  1584. qhull configuration warning (qh_RANDOMmax in user.h):\n\
    1585. 

  1585.    average of 1000 random integers (%.2g) is much different than expected (%.2g).\n\
    1586. 

  1586.    Is qh_RANDOMmax (%.2g) wrong?\n",
    1587. 

  1587. 	     randr, qh_RANDOMmax/2.0, qh_RANDOMmax);
    1588. 

  1588.   qh RANDOMa= 2.0 * qh RANDOMfactor/qh_RANDOMmax;
    1589. 

  1589.   qh RANDOMb= 1.0 - qh RANDOMfactor;
    1590. 

  1590.   if (qh_HASHfactor < 1.1) {
    1591. 

  1591.     fprintf(qh ferr, "qhull internal error (qh_initqhull_globals): qh_HASHfactor %d must be at least 1.1.  Qhull uses linear hash probing\n",
    1592. 

  1592.       qh_HASHfactor);
    1593. 

  1593.     qh_errexit (qh_ERRqhull, NULL, NULL);
    1594. 

  1594.   }
    1595. 

  1595.   if (numpoints+extra < pointsneeded) {
    1596. 

  1596.     fprintf(qh ferr,"qhull input error: not enough points (%d) to construct initial simplex (need %d)\n",
    1597. 

  1597. 	    numpoints, pointsneeded);
    1598. 

  1598.     qh_errexit(qh_ERRinput, NULL, NULL);
    1599. 

  1599.   }
    1600. 

  1600.   if (qh PRINTtransparent) {
    1601. 

  1601.     if (qh hull_dim != 4 || !qh DELAUNAY || qh VORONOI || qh DROPdim >= 0) {
    1602. 

  1602.       fprintf(qh ferr,"qhull input error: transparent Delaunay ('Gt') needs 3-d Delaunay ('d') w/o 'GDn'\n");
    1603. 

  1603.       qh_errexit(qh_ERRinput, NULL, NULL);
    1604. 

  1604.     }
    1605. 

  1605.     qh DROPdim = 3;
    1606. 

  1606.     qh PRINTridges = True;
    1607. 

  1607.   }
    1608. 

  1608.   for (i= qh_PRINTEND; i--; ) {
    1609. 

  1609.     if (qh PRINTout[i] == qh_PRINTgeom)
    1610. 

  1610.       printgeom= True;
    1611. 

  1611.     else if (qh PRINTout[i] == qh_PRINTmathematica || qh PRINTout[i] == qh_PRINTmaple)
    1612. 

  1612.       printmath= True;
    1613. 

  1613.     else if (qh PRINTout[i] == qh_PRINTcoplanars)
    1614. 

  1614.       printcoplanar= True;
    1615. 

  1615.     else if (qh PRINTout[i] == qh_PRINTpointnearest)
    1616. 

  1616.       printcoplanar= True;
    1617. 

  1617.     else if (qh PRINTout[i] == qh_PRINTpointintersect && !qh HALFspace) {
    1618. 

  1618.       fprintf (qh ferr, "qhull input error: option 'Fp' is only used for \nhalfspace intersection ('Hn,n,n').\n");
    1619. 

  1619.       qh_errexit (qh_ERRinput, NULL, NULL);
    1620. 

  1620.     }else if (qh PRINTout[i] == qh_PRINTtriangles && (qh HALFspace || qh VORONOI)) {
    1621. 

  1621.       fprintf (qh ferr, "qhull input error: option 'Ft' is not available
    1622.