Skip to content

AFNI/NIfTI Server

Sections
Personal tools
You are here: Home » AFNI » Documentation
 

Doxygen Source Code Documentation

Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals   Search  

qset.c File Reference

#include <stdio.h>
#include <string.h>
#include "qset.h"
#include "mem.h"

Go to the source code of this file.


Defines

#define SETsizeaddr_(set)   (&((set)->e[(set)->maxsize].i))

Typedefs

typedef ridgeT ridgeT
typedef facetT facetT

Functions

void qh_errexit (int exitcode, facetT *, ridgeT *)
void qh_setaddnth (setT **setp, int nth, void *newelem)
void qh_setaddsorted (setT **setp, void *newelem)
void qh_setappend (setT **setp, void *newelem)
void qh_setappend_set (setT **setp, setT *setA)
void qh_setappend2ndlast (setT **setp, void *newelem)
void qh_setcheck (setT *set, char *tname, int id)
void qh_setcompact (setT *set)
setT * qh_setcopy (setT *set, int extra)
void * qh_setdel (setT *set, void *oldelem)
void * qh_setdellast (setT *set)
void * qh_setdelnth (setT *set, int nth)
void * qh_setdelnthsorted (setT *set, int nth)
void * qh_setdelsorted (setT *set, void *oldelem)
setT * qh_setduplicate (setT *set, int elemsize)
int qh_setequal (setT *setA, setT *setB)
int qh_setequal_except (setT *setA, void *skipelemA, setT *setB, void *skipelemB)
int qh_setequal_skip (setT *setA, int skipA, setT *setB, int skipB)
void qh_setfree (setT **setp)
void qh_setfree2 (setT **setp, int elemsize)
void qh_setfreelong (setT **setp)
int qh_setin (setT *set, void *setelem)
int qh_setindex (setT *set, void *atelem)
void qh_setlarger (setT **oldsetp)
void * qh_setlast (setT *set)
setT * qh_setnew (int setsize)
setT * qh_setnew_delnthsorted (setT *set, int size, int nth, int prepend)
void qh_setprint (FILE *fp, char *string, setT *set)
void qh_setreplace (setT *set, void *oldelem, void *newelem)
int qh_setsize (setT *set)
setT * qh_settemp (int setsize)
void qh_settempfree (setT **set)
void qh_settempfree_all (void)
setT * qh_settemppop (void)
void qh_settemppush (setT *set)
void qh_settruncate (setT *set, int size)
int qh_setunique (setT **set, void *elem)
void qh_setzero (setT *set, int index, int size)

Define Documentation

#define SETsizeaddr_ (  set    )     (&((set)->e[(set)->maxsize].i))
 

Definition at line 38 of file qset.c.

Referenced by qh_setaddnth(), qh_setappend(), qh_setappend2ndlast(), qh_setappend_set(), qh_setcopy(), qh_setdel(), qh_setdellast(), qh_setdelnth(), qh_setdelnthsorted(), qh_setdelsorted(), qh_setlarger(), qh_setlast(), and qh_setsize().

Typedef Documentation

typedef struct facetT facetT
 

Definition at line 23 of file qset.c.

typedef struct ridgeT ridgeT
 

Definition at line 22 of file qset.c.

Function Documentation

void qh_errexit (  int    exitcode,
facetT *   ,
ridgeT *   
) 
 

Definition at line 192 of file user.c.

References qh, qh_collectstatistics(), qh_CPUclock, qh_ERRprec, qh_errprint(), qh_ERRqhull, qh_ERRsingular, qh_memstatistics(), qh_printhelp_degenerate(), qh_printhelp_singular(), qh_printstatistics(), qh_printstats(), qh_printsummary(), qh_produce_output(), qhstat, Zsetplane, Ztotmerge, and zzval_.

Referenced by qh_addpoint(), qh_build_withrestart(), qh_buildhull(), qh_checkconnect(), qh_checkconvex(), qh_checkfacet(), qh_checkflags(), qh_checkflipped_all(), qh_checkpolygon(), qh_checkvertex(), qh_clock(), qh_copypoints(), qh_deletevisible(), qh_determinant(), qh_detroundoff(), qh_detsimplex(), qh_detvnorm(), qh_detvridge3(), qh_errexit2(), qh_facet3vertex(), qh_facetarea_simplex(), qh_findbest(), qh_findbestfacet(), qh_findbestneighbor(), qh_findbestnew(), qh_findhorizon(), qh_getcenter(), qh_infiniteloop(), qh_initbuild(), qh_initflags(), qh_initialhull(), qh_initqhull_globals(), qh_joggleinput(), qh_matchduplicates(), qh_matchnewfacets(), qh_maxmin(), qh_maxsimplex(), qh_memalloc(), qh_meminitbuffers(), qh_memsetup(), qh_memsize(), qh_mergecycle_all(), qh_mergecycle_ridges(), qh_mergefacet(), qh_mergevertices(), qh_newvertex(), qh_nextfurthest(), qh_order_vertexneighbors(), qh_point_add(), qh_printafacet(), qh_printbegin(), qh_printend(), qh_printvdiagram(), qh_produce_output(), qh_projectinput(), qh_projectpoints(), qh_qhull(), qh_readfeasible(), qh_readpoints(), qh_rename_sharedvertex(), qh_scalelast(), qh_scalepoints(), qh_setaddnth(), qh_setcheck(), qh_setdelnth(), qh_setdelnthsorted(), qh_setfeasible(), qh_sethalfspace_all(), qh_setnew_delnthsorted(), qh_setreplace(), qh_setsize(), qh_settempfree(), qh_settemppop(), qh_settruncate(), qh_setzero(), qh_tracemerge(), and qh_voronoi_center(). 

00192                                                             {
00193 
00194   if (qh ERREXITcalled) {
00195     fprintf (qh ferr, "\nqhull error while processing previous error.  Exit program\n");
00196     exit(1);
00197   }
00198   qh ERREXITcalled= True;
00199   if (!qh QHULLfinished)
00200     qh hulltime= qh_CPUclock - qh hulltime;
00201   qh_errprint("ERRONEOUS", facet, NULL, ridge, NULL);
00202   fprintf (qh ferr, "\nWhile executing: %s | %s\n", qh rbox_command, qh qhull_command);
00203   fprintf(qh ferr, "Options selected for Qhull %s:\n%s\n", qh_version, qh qhull_options);
00204   if (qh furthest_id >= 0) {
00205     fprintf(qh ferr, "Last point added to hull was p%d.", qh furthest_id);
00206     if (zzval_(Ztotmerge))
00207       fprintf(qh ferr, "  Last merge was #%d.", zzval_(Ztotmerge));
00208     if (qh QHULLfinished)
00209       fprintf(qh ferr, "\nQhull has finished constructing the hull.");
00210     else if (qh POSTmerging)
00211       fprintf(qh ferr, "\nQhull has started post-merging.");
00212     fprintf (qh ferr, "\n");
00213   }
00214   if (qh FORCEoutput && (qh QHULLfinished || (!facet && !ridge)))
00215     qh_produce_output();
00216   else {
00217     if (exitcode != qh_ERRsingular && zzval_(Zsetplane) > qh hull_dim+1) {
00218       fprintf (qh ferr, "\nAt error exit:\n");
00219       qh_printsummary (qh ferr);
00220       if (qh PRINTstatistics) {
00221         qh_collectstatistics();
00222         qh_printstatistics(qh ferr, "at error exit");
00223         qh_memstatistics (qh ferr);
00224       }
00225     }
00226     if (qh PRINTprecision)
00227       qh_printstats (qh ferr, qhstat precision, NULL);
00228   }
00229   if (!exitcode)
00230     exitcode= qh_ERRqhull;
00231   else if (exitcode == qh_ERRsingular)
00232     qh_printhelp_singular(qh ferr);
00233   else if (exitcode == qh_ERRprec && !qh PREmerge)
00234     qh_printhelp_degenerate (qh ferr);
00235   if (qh NOerrexit) {
00236     fprintf (qh ferr, "qhull error while ending program.  Exit program\n");
00237     exit(1);
00238   }
00239   qh NOerrexit= True;
00240   longjmp(qh errexit, exitcode);
00241 } /* errexit */

void qh_setaddnth (  setT **    setp,
int    nth,
void *    newelem
) 
 

Definition at line 59 of file qset.c.

References i, qh_errexit(), qh_setlarger(), qh_setprint(), qhmem_ERRqhull, SETelemaddr_, and SETsizeaddr_.

Referenced by qh_appendmergeset(), qh_facet3vertex(), qh_initialvertices(), qh_mergecycle(), qh_mergesimplex(), qh_renameridgevertex(), and qh_setaddsorted(). 

00059                                                        {
00060   int *sizep, oldsize, i;
00061   void **oldp, **newp;
00062 
00063   if (!*setp || !*(sizep= SETsizeaddr_(*setp))) {
00064     qh_setlarger(setp);
00065     sizep= SETsizeaddr_(*setp);
00066   }
00067   oldsize= *sizep - 1;
00068   if (nth < 0 || nth > oldsize) {
00069     fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00070     qh_setprint (qhmem.ferr, "", *setp);
00071     qh_errexit (qhmem_ERRqhull, NULL, NULL);
00072   }
00073   (*sizep)++;
00074   oldp= SETelemaddr_(*setp, oldsize, void);   /* NULL */
00075   newp= oldp+1;
00076   for (i= oldsize-nth+1; i--; )  /* move at least NULL  */
00077     *(newp--)= *(oldp--);       /* may overwrite *sizep */
00078   *newp= newelem;
00079 } /* setaddnth */

void qh_setaddsorted (  setT **    setp,
void *    newelem
) 
 

Definition at line 97 of file qset.c.

References FOREACHelem_, and qh_setaddnth(). 

00097                                                  {
00098   int newindex=0;
00099   void *elem, **elemp;
00100 
00101   FOREACHelem_(*setp) {          /* could use binary search instead */
00102     if (elem < newelem)
00103       newindex++;
00104     else if (elem == newelem)
00105       return;
00106     else
00107       break;
00108   }
00109   qh_setaddnth(setp, newindex, newelem);
00110 } /* setaddsorted */

void qh_setappend (  setT **    setp,
void *    newelem
) 
 

Definition at line 128 of file qset.c.

References qh_setlarger(), and SETsizeaddr_.

Referenced by qh_addpoint(), qh_appendmergeset(), qh_attachnewfacets(), qh_basevertices(), qh_createsimplex(), qh_detvnorm(), qh_detvridge(), qh_detvridge3(), qh_facet3vertex(), qh_facetcenter(), qh_facetvertices(), qh_findbest(), qh_flippedmerges(), qh_forcedmerges(), qh_furthestout(), qh_initialvertices(), qh_makenew_nonsimplicial(), qh_makenewfacet(), qh_makeridges(), qh_mark_dupridges(), qh_markkeep(), qh_maxmin(), qh_maxsimplex(), qh_merge_degenredundant(), qh_mergecycle_neighbors(), qh_mergecycle_ridges(), qh_mergecycle_vneighbors(), qh_mergeneighbors(), qh_mergeridges(), qh_mergesimplex(), qh_mergevertex_del(), qh_mergevertices(), qh_order_vertexneighbors(), qh_partitionall(), qh_partitioncoplanar(), qh_partitionpoint(), qh_printfacet3geom_nonsimplicial(), qh_printfacet3geom_points(), qh_printfacet3geom_simplicial(), qh_printfacet3math(), qh_printneighborhood(), qh_remove_extravertices(), qh_renamevertex(), qh_setduplicate(), qh_settemp(), qh_settemppush(), qh_setunique(), qh_updatevertices(), qh_vertexintersect_new(), qh_vertexneighbors(), and qh_vertexridges_facet(). 

00128                                               {
00129   int *sizep;
00130   void **endp;
00131 
00132   if (!newelem)
00133     return;
00134   if (!*setp || !*(sizep= SETsizeaddr_(*setp))) {
00135     qh_setlarger(setp);
00136     sizep= SETsizeaddr_(*setp);
00137   }
00138   *(endp= &((*setp)->e[(*sizep)++ - 1].p))= newelem;
00139   *(++endp)= NULL;
00140 } /* setappend */

void qh_setappend2ndlast (  setT **    setp,
void *    newelem
) 
 

Definition at line 199 of file qset.c.

References qh_setlarger(), SETelemaddr_, and SETsizeaddr_.

Referenced by qh_partitioncoplanar(), and qh_partitionpoint(). 

00199                                                      {
00200   int *sizep;
00201   void **endp, **lastp;
00202   
00203   if (!*setp || !*(sizep= SETsizeaddr_(*setp))) {
00204     qh_setlarger(setp);
00205     sizep= SETsizeaddr_(*setp);
00206   }
00207   endp= SETelemaddr_(*setp, (*sizep)++ -1, void); /* NULL */
00208   lastp= endp-1;
00209   *(endp++)= *lastp;
00210   *endp= NULL;    /* may overwrite *sizep */
00211   *lastp= newelem;
00212 } /* setappend2ndlast */

void qh_setappend_set (  setT **    setp,
setT *    setA
) 
 

Definition at line 157 of file qset.c.

References setT::e, setelemT::p, qh_setcopy(), qh_setfree(), qh_setnew(), SETelemsize, SETreturnsize_, and SETsizeaddr_.

Referenced by qh_makenew_nonsimplicial(). 

00157                                                {
00158   int *sizep, sizeA, size;
00159   setT *oldset;
00160 
00161   if (!setA)
00162     return;
00163   SETreturnsize_(setA, sizeA);
00164   if (!*setp)
00165     *setp= qh_setnew (sizeA);
00166   sizep= SETsizeaddr_(*setp);
00167   if (!(size= *sizep))
00168     size= (*setp)->maxsize;
00169   else
00170     size--;
00171   if (size + sizeA > (*setp)->maxsize) {
00172     oldset= *setp;
00173     *setp= qh_setcopy (oldset, sizeA);
00174     qh_setfree (&oldset);
00175     sizep= SETsizeaddr_(*setp);
00176   }
00177   *sizep= size+sizeA+1;   /* memcpy may overwrite */
00178   if (sizeA > 0) 
00179     memcpy((char *)&((*setp)->e[size].p), (char *)&(setA->e[0].p), SETelemsize *(sizeA+1));
00180 } /* setappend_set */

void qh_setcheck (  setT *    set,
char *    tname,
int    id
) 
 

Definition at line 225 of file qset.c.

References setT::e, setT::maxsize, setelemT::p, qh_errexit(), qh_setprint(), qhmem_ERRqhull, and SETreturnsize_.

Referenced by qh_checkfacet(), and qh_checkpolygon(). 

00225                                                  {
00226   int maxsize, size;
00227   int waserr= 0;
00228 
00229   if (!set)
00230     return;
00231   SETreturnsize_(set, size);
00232   maxsize= set->maxsize;
00233   if (size > maxsize || !maxsize) {
00234     fprintf (qhmem.ferr, "qhull internal error (qh_setcheck): actual size %d of %s%d is greater than max size %d\n",
00235              size, tname, id, maxsize);
00236     waserr= 1;
00237   }else if (set->e[size].p) {
00238     fprintf (qhmem.ferr, "qhull internal error (qh_setcheck): %s%d (size %d max %d) is not null terminated.\n",
00239              tname, id, maxsize, size-1);
00240     waserr= 1;
00241   }
00242   if (waserr) {
00243     qh_setprint (qhmem.ferr, "ERRONEOUS", set);
00244     qh_errexit (qhmem_ERRqhull, NULL, NULL);
00245   }
00246 } /* setcheck */

void qh_setcompact (  setT *    set ) 
 

Definition at line 267 of file qset.c.

References qh_settruncate(), SETaddr_, and SETreturnsize_.

Referenced by qh_mergecycle_neighbors(), qh_mergecycle_ridges(), qh_mergecycle_vneighbors(), qh_nearcoplanar(), and qh_updatevertices(). 

00267                               {
00268   int size;
00269   void **destp, **elemp, **endp, **firstp;
00270 
00271   if (!set)
00272     return;
00273   SETreturnsize_(set, size);
00274   destp= elemp= firstp= SETaddr_(set, void);
00275   endp= destp + size;
00276   while (1) {
00277     if (!(*destp++ = *elemp++)) {
00278       destp--;
00279       if (elemp > endp)
00280         break;
00281     }
00282   }
00283   qh_settruncate (set, destp-firstp);
00284 } /* setcompact */

setT* qh_setcopy (  setT *    set,
int    extra
) 
 

Definition at line 301 of file qset.c.

References setT::e, setelemT::p, qh_setnew(), SETelemsize, SETreturnsize_, and SETsizeaddr_.

Referenced by qh_neighbor_intersections(), and qh_setappend_set(). 

00301                                        {
00302   setT *newset;
00303   int size;
00304 
00305   if (extra < 0)
00306     extra= 0;
00307   SETreturnsize_(set, size);
00308   newset= qh_setnew(size+extra);
00309   *SETsizeaddr_(newset)= size+1;    /* memcpy may overwrite */
00310   memcpy((char *)&(newset->e[0].p), (char *)&(set->e[0].p), SETelemsize *(size+1));
00311   return (newset);
00312 } /* setcopy */

void* qh_setdel (  setT *    set,
void *    oldelem
) 
 

Definition at line 335 of file qset.c.

References setT::maxsize, SETaddr_, SETelemaddr_, and SETsizeaddr_.

Referenced by qh_attachnewfacets(), qh_delridge(), qh_furthestout(), qh_makenew_nonsimplicial(), qh_makeridges(), qh_maydropneighbor(), qh_merge_degenredundant(), qh_mergecycle_neighbors(), qh_mergecycle_ridges(), qh_mergeneighbors(), qh_mergesimplex(), qh_mergevertex_neighbors(), qh_order_vertexneighbors(), qh_remove_extravertices(), qh_rename_sharedvertex(), qh_renamevertex(), and qh_updatevertices(). 

00335                                           {
00336   void **elemp, **lastp;
00337   int *sizep;
00338 
00339   if (!set)
00340     return NULL;
00341   elemp= SETaddr_(set, void);
00342   while (*elemp != oldelem && *elemp)
00343     elemp++;
00344   if (*elemp) {
00345     sizep= SETsizeaddr_(set);
00346     if (!(*sizep)--)         /*  if was a full set */
00347       *sizep= set->maxsize;  /*     *sizep= (maxsize-1)+ 1 */
00348     lastp= SETelemaddr_(set, *sizep-1, void);
00349     *elemp= *lastp;      /* may overwrite itself */
00350     *lastp= NULL;
00351     return oldelem;
00352   }
00353   return NULL;
00354 } /* setdel */

void* qh_setdellast (  setT *    set ) 
 

Definition at line 374 of file qset.c.

References setT::e, setT::maxsize, setelemT::p, and SETsizeaddr_.

Referenced by qh_all_merges(), qh_findbest(), qh_initialvertices(), qh_merge_degenredundant(), qh_nextfurthest(), qh_order_vertexneighbors(), and qh_settemppop(). 

00374                                {
00375   int setsize;  /* actually, actual_size + 1 */
00376   int maxsize;
00377   int *sizep;
00378   void *returnvalue;
00379   
00380   if (!set || !(set->e[0].p))
00381     return NULL;
00382   sizep= SETsizeaddr_(set);
00383   if ((setsize= *sizep)) {
00384     returnvalue= set->e[setsize - 2].p;
00385     set->e[setsize - 2].p= NULL;
00386     (*sizep)--;
00387   }else {
00388     maxsize= set->maxsize;
00389     returnvalue= set->e[maxsize - 1].p;
00390     set->e[maxsize - 1].p= NULL;
00391     *sizep= maxsize;
00392   }
00393   return returnvalue;
00394 } /* setdellast */

void* qh_setdelnth (  setT *    set,
int    nth
) 
 

Definition at line 414 of file qset.c.

References setT::maxsize, qh_errexit(), qh_setprint(), qhmem_ERRqhull, SETelemaddr_, and SETsizeaddr_.

Referenced by qh_attachnewfacets(), qh_detvnorm(), qh_find_newvertex(), and qh_nextfurthest(). 

00414                                        {
00415   void **elemp, **lastp, *elem;
00416   int *sizep;
00417 
00418 
00419   elemp= SETelemaddr_(set, nth, void);
00420   sizep= SETsizeaddr_(set);
00421   if (!(*sizep)--)         /*  if was a full set */
00422     *sizep= set->maxsize;  /*     *sizep= (maxsize-1)+ 1 */
00423   if (nth < 0 || nth >= *sizep) {
00424     fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00425     qh_setprint (qhmem.ferr, "", set);
00426     qh_errexit (qhmem_ERRqhull, NULL, NULL);
00427   }
00428   lastp= SETelemaddr_(set, *sizep-1, void);
00429   elem= *elemp;
00430   *elemp= *lastp;      /* may overwrite itself */
00431   *lastp= NULL;
00432   return elem;
00433 } /* setdelnth */

void* qh_setdelnthsorted (  setT *    set,
int    nth
) 
 

Definition at line 455 of file qset.c.

References setT::maxsize, qh_errexit(), qh_setprint(), qhmem_ERRqhull, SETelemaddr_, and SETsizeaddr_.

Referenced by qh_renameridgevertex(). 

00455                                              {
00456   void **newp, **oldp, *elem;
00457   int *sizep;
00458 
00459   sizep= SETsizeaddr_(set);
00460   if (nth < 0 || (*sizep && nth >= *sizep-1) || nth >= set->maxsize) {
00461     fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00462     qh_setprint (qhmem.ferr, "", set);
00463     qh_errexit (qhmem_ERRqhull, NULL, NULL);
00464   }
00465   newp= SETelemaddr_(set, nth, void);
00466   elem= *newp;
00467   oldp= newp+1;
00468   while ((*(newp++)= *(oldp++)))
00469     ; /* copy remaining elements and NULL */
00470   if (!(*sizep)--)         /*  if was a full set */
00471     *sizep= set->maxsize;  /*     *sizep= (max size-1)+ 1 */
00472   return elem;
00473 } /* setdelnthsorted */

void* qh_setdelsorted (  setT *    set,
void *    oldelem
) 
 

Definition at line 493 of file qset.c.

References setT::maxsize, SETaddr_, and SETsizeaddr_.

Referenced by qh_mergecycle_vneighbors(), qh_mergevertex_del(), qh_neighbor_intersections(), qh_remove_extravertices(), and qh_renamevertex(). 

00493                                                 {
00494   void **newp, **oldp;
00495   int *sizep;
00496 
00497   if (!set)
00498     return NULL;
00499   newp= SETaddr_(set, void);
00500   while(*newp != oldelem && *newp)
00501     newp++;
00502   if (*newp) {
00503     oldp= newp+1;
00504     while ((*(newp++)= *(oldp++)))
00505       ; /* copy remaining elements */
00506     sizep= SETsizeaddr_(set);
00507     if (!(*sizep)--)    /*  if was a full set */
00508       *sizep= set->maxsize;  /*     *sizep= (max size-1)+ 1 */
00509     return oldelem;
00510   }
00511   return NULL;
00512 } /* setdelsorted */

setT* qh_setduplicate (  setT *    set,
int    elemsize
) 
 

Definition at line 530 of file qset.c.

References FOREACHelem_, qh_memalloc(), qh_setappend(), qh_setnew(), and qh_setsize(). 

00530                                                 {
00531   void          *elem, **elemp, *newElem;
00532   setT          *newSet;
00533   int           size;
00534   
00535   if (!(size= qh_setsize (set)))
00536     return NULL;
00537   newSet= qh_setnew (size);
00538   FOREACHelem_(set) {
00539     newElem= qh_memalloc (elemsize);
00540     memcpy (newElem, elem, elemsize);
00541     qh_setappend (&newSet, newElem);
00542   }
00543   return newSet;
00544 } /* setduplicate */

int qh_setequal (  setT *    setA,
setT *    setB
) 
 

Definition at line 561 of file qset.c.

References memcmp(), SETaddr_, SETelemsize, and SETreturnsize_.

Referenced by qh_checkfacet(). 

00561                                         {
00562   void **elemAp, **elemBp;
00563   int sizeA, sizeB;
00564   
00565   SETreturnsize_(setA, sizeA);
00566   SETreturnsize_(setB, sizeB);
00567   if (sizeA != sizeB)
00568     return 0;
00569   if (!sizeA)
00570     return 1;
00571   elemAp= SETaddr_(setA, void);
00572   elemBp= SETaddr_(setB, void);
00573   if (!memcmp((char *)elemAp, (char *)elemBp, sizeA*SETelemsize))
00574     return 1;
00575   return 0;
00576 } /* setequal */

int qh_setequal_except (  setT *    setA,
void *    skipelemA,
setT *    setB,
void *    skipelemB
) 
 

Definition at line 599 of file qset.c.

References SETaddr_, and skip.

Referenced by qh_hashridge_find(). 

00599                                                                                   {
00600   void **elemA, **elemB;
00601   int skip=0;
00602 
00603   elemA= SETaddr_(setA, void);
00604   elemB= SETaddr_(setB, void);
00605   while (1) {
00606     if (*elemA == skipelemA) {
00607       skip++;
00608       elemA++;
00609     }
00610     if (skipelemB) {
00611       if (*elemB == skipelemB) {
00612         skip++;
00613         elemB++;
00614       }
00615     }else if (*elemA != *elemB) {
00616       skip++;
00617       if (!(skipelemB= *elemB++))
00618         return 0;
00619     }
00620     if (!*elemA)
00621       break;
00622     if (*elemA++ != *elemB++) 
00623       return 0;
00624   }
00625   if (skip != 2 || *elemB)
00626     return 0;
00627   return 1;
00628 } /* setequal_except */

int qh_setequal_skip (  setT *    setA,
int    skipA,
setT *    setB,
int    skipB
) 
 

Definition at line 647 of file qset.c.

References SETaddr_, and SETelemaddr_.

Referenced by qh_attachnewfacets(), and qh_checkfacet(). 

00647                                                                     {
00648   void **elemA, **elemB, **skipAp, **skipBp;
00649 
00650   elemA= SETaddr_(setA, void);
00651   elemB= SETaddr_(setB, void);
00652   skipAp= SETelemaddr_(setA, skipA, void);
00653   skipBp= SETelemaddr_(setB, skipB, void);
00654   while (1) {
00655     if (elemA == skipAp)
00656       elemA++;
00657     if (elemB == skipBp)
00658       elemB++;
00659     if (!*elemA)
00660       break;
00661     if (*elemA++ != *elemB++) 
00662       return 0;
00663   }
00664   if (*elemB)
00665     return 0;
00666   return 1;
00667 } /* setequal_skip */

void qh_setfree (  setT **    setp ) 
 

Definition at line 686 of file qset.c.

References qh_memfree(), qh_memfree_, and SETelemsize.

Referenced by qh_attachnewfacets(), qh_delfacet(), qh_delridge(), qh_delvertex(), qh_find_newvertex(), qh_freebuffers(), qh_freebuild(), qh_makenew_nonsimplicial(), qh_matchnewfacets(), qh_mergecycle_ridges(), qh_mergesimplex(), qh_mergevertices(), qh_nearcoplanar(), qh_nextfurthest(), qh_order_vertexneighbors(), qh_outcoplanar(), qh_partitionall(), qh_printfacet3geom_simplicial(), qh_printfacet4geom_simplicial(), qh_setappend_set(), qh_setfree2(), qh_setlarger(), qh_settempfree(), and qh_settempfree_all(). 

00686                              {
00687   int size;
00688   void **freelistp;  /* used !qh_NOmem */
00689   
00690   if (*setp) {
00691     size= sizeof(setT) + ((*setp)->maxsize)*SETelemsize; 
00692     if (size <= qhmem.LASTsize) {
00693       qh_memfree_(*setp, size, freelistp);
00694     }else
00695       qh_memfree (*setp, size);
00696     *setp= NULL;
00697   }
00698 } /* setfree */

void qh_setfree2 (  setT **    setp,
int    elemsize
) 
 

Definition at line 714 of file qset.c.

References FOREACHelem_, qh_memfree(), and qh_setfree(). 

00714                                              {
00715   void          *elem, **elemp;
00716   
00717   FOREACHelem_(*setp)
00718     qh_memfree (elem, elemsize);
00719   qh_setfree (setp);
00720 } /* setfree2 */

void qh_setfreelong (  setT **    setp ) 
 

Definition at line 740 of file qset.c.

References qh_memfree(), and SETelemsize.

Referenced by qh_freebuild(). 

00740                                  {
00741   int size;
00742   
00743   if (*setp) {
00744     size= sizeof(setT) + ((*setp)->maxsize)*SETelemsize; 
00745     if (size > qhmem.LASTsize) {
00746       qh_memfree (*setp, size);
00747       *setp= NULL;
00748     }
00749   }
00750 } /* setfreelong */

int qh_setin (  setT *    set,
void *    setelem
) 
 

Definition at line 765 of file qset.c.

References FOREACHelem_.

Referenced by qh_checkfacet(), qh_checkvertex(), qh_detvnorm(), qh_detvridge3(), qh_forcedmerges(), qh_initialvertices(), qh_mark_dupridges(), qh_maxsimplex(), qh_order_vertexneighbors(), qh_setunique(), and qh_vertexridges_facet(). 

00765                                        {
00766   void *elem, **elemp;
00767 
00768   FOREACHelem_(set) {
00769     if (elem == setelem)
00770       return 1;
00771   }
00772   return 0;
00773 } /* setin */

int qh_setindex (  setT *    set,
void *    atelem
) 
 

Definition at line 790 of file qset.c.

References i, setT::maxsize, SETaddr_, and SETreturnsize_.

Referenced by qh_checkfacet(), qh_matchneighbor(), qh_pointid(), and qh_renameridgevertex(). 

00790                                          {
00791   void **elem;
00792   int size, i;
00793 
00794   SETreturnsize_(set, size);
00795   if (size > set->maxsize)
00796     return -1;
00797   elem= SETaddr_(set, void);
00798   for (i=0; i < size; i++) {
00799     if (*elem++ == atelem)
00800       return i;
00801   }
00802   return -1;
00803 } /* setindex */

void qh_setlarger (  setT **    oldsetp ) 
 

Definition at line 822 of file qset.c.

References FOREACHset_, qh_setfree(), qh_setnew(), SETaddr_, SETelemsize, SETreturnsize_, and SETsizeaddr_.

Referenced by qh_setaddnth(), qh_setappend(), and qh_setappend2ndlast(). 

00822                                   {
00823   int size= 1, *sizep;
00824   setT *newset, *set, **setp, *oldset;
00825   void **oldp, **newp;
00826 
00827   if (*oldsetp) {
00828     oldset= *oldsetp;
00829     SETreturnsize_(oldset, size);
00830     qhmem.cntlarger++;
00831     qhmem.totlarger += size+1;
00832     newset= qh_setnew(2 * size);
00833     oldp= SETaddr_(oldset, void);
00834     newp= SETaddr_(newset, void);
00835     memcpy((char *)newp, (char *)oldp, (size+1) * SETelemsize);
00836     sizep= SETsizeaddr_(newset);
00837     *sizep= size+1;
00838     FOREACHset_((setT *)qhmem.tempstack) {
00839       if (set == oldset)
00840         *(setp-1)= newset;
00841     }
00842     qh_setfree(oldsetp);
00843   }else 
00844     newset= qh_setnew(3);
00845   *oldsetp= newset;
00846 } /* setlarger */

void* qh_setlast (  setT *    set ) 
 

Definition at line 861 of file qset.c.

References setT::maxsize, SETelem_, and SETsizeaddr_.

Referenced by qh_appendmergeset(), qh_furthestnext(), qh_nextfurthest(), qh_partitioncoplanar(), qh_partitionpoint(), and qh_printfacetheader(). 

00861                             {
00862   int size;
00863 
00864   if (set) {
00865     size= *SETsizeaddr_(set);
00866     if (!size) 
00867       return SETelem_(set, set->maxsize - 1);
00868     else if (size > 1)
00869       return SETelem_(set, size - 2);
00870   }
00871   return NULL;
00872 } /* setlast */

setT* qh_setnew (  int    setsize ) 
 

Definition at line 890 of file qset.c.

References setT::e, setelemT::i, setT::maxsize, setelemT::p, qh_memalloc(), qh_memalloc_, and SETelemsize.

Referenced by qh_initqhull_buffers(), qh_makenew_nonsimplicial(), qh_newfacet(), qh_newhashtable(), qh_partitionall(), qh_setappend_set(), qh_setcopy(), qh_setduplicate(), qh_setlarger(), qh_setnew_delnthsorted(), qh_settemp(), qh_vertexintersect_new(), and qh_vertexneighbors(). 

00890                              {
00891   setT *set;
00892   int sizereceived; /* used !qh_NOmem */
00893   int size;
00894   void **freelistp; /* used !qh_NOmem */
00895 
00896   if (!setsize)
00897     setsize++;
00898   size= sizeof(setT) + setsize * SETelemsize;
00899   if ((unsigned) size <= (unsigned) qhmem.LASTsize) {
00900     qh_memalloc_(size, freelistp, set, setT);
00901 #ifndef qh_NOmem
00902     sizereceived= qhmem.sizetable[ qhmem.indextable[size]];
00903     if (sizereceived > size) 
00904       setsize += (sizereceived - size)/SETelemsize;
00905 #endif
00906   }else
00907     set= (setT*)qh_memalloc (size);
00908   set->maxsize= setsize;
00909   set->e[setsize].i= 1;
00910   set->e[0].p= NULL;
00911   return (set);
00912 } /* setnew */

setT* qh_setnew_delnthsorted (  setT *    set,
int    size,
int    nth,
int    prepend
) 
 

Definition at line 933 of file qset.c.

References setT::e, setT::maxsize, qh_errexit(), qh_setnew(), qh_setprint(), qhmem_ERRqhull, SETaddr_, and SETelemsize.

Referenced by qh_createsimplex(), qh_facetintersect(), qh_makeridges(), qh_mergecycle_ridges(), qh_printfacet3geom_simplicial(), and qh_printfacet4geom_simplicial(). 

00933                                                                         {
00934   setT *newset;
00935   void **oldp, **newp;
00936   int tailsize= size - nth -1, newsize;
00937 
00938   if (tailsize < 0) {
00939     fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00940     qh_setprint (qhmem.ferr, "", set);
00941     qh_errexit (qhmem_ERRqhull, NULL, NULL);
00942   }
00943   newsize= size-1 + prepend;
00944   newset= qh_setnew(newsize);
00945   newset->e[newset->maxsize].i= newsize+1;  /* may be overwritten */
00946   oldp= SETaddr_(set, void);
00947   newp= SETaddr_(newset, void) + prepend;
00948   switch (nth) {
00949   case 0:
00950     break;
00951   case 1:
00952     *(newp++)= *oldp++;
00953     break;
00954   case 2:
00955     *(newp++)= *oldp++;
00956     *(newp++)= *oldp++;
00957     break;
00958   case 3:
00959     *(newp++)= *oldp++;
00960     *(newp++)= *oldp++;
00961     *(newp++)= *oldp++;
00962     break;
00963   case 4:
00964     *(newp++)= *oldp++;
00965     *(newp++)= *oldp++;
00966     *(newp++)= *oldp++;
00967     *(newp++)= *oldp++;
00968     break;
00969   default:
00970     memcpy((char *)newp, (char *)oldp, nth * SETelemsize);
00971     newp += nth;
00972     oldp += nth;
00973     break;
00974   }
00975   oldp++;
00976   switch (tailsize) {
00977   case 0:
00978     break;
00979   case 1:
00980     *(newp++)= *oldp++;
00981     break;
00982   case 2:
00983     *(newp++)= *oldp++;
00984     *(newp++)= *oldp++;
00985     break;
00986   case 3:
00987     *(newp++)= *oldp++;
00988     *(newp++)= *oldp++;
00989     *(newp++)= *oldp++;
00990     break;
00991   case 4:
00992     *(newp++)= *oldp++;
00993     *(newp++)= *oldp++;
00994     *(newp++)= *oldp++;
00995     *(newp++)= *oldp++;
00996     break;
00997   default:
00998     memcpy((char *)newp, (char *)oldp, tailsize * SETelemsize);
00999     newp += tailsize;
01000   }
01001   *newp= NULL;
01002   return(newset);
01003 } /* setnew_delnthsorted */

void qh_setprint (  FILE *    fp,
char *    string,
setT *    set
) 
 

Definition at line 1015 of file qset.c.

References setT::e, setT::maxsize, setelemT::p, and SETreturnsize_.

Referenced by qh_checkfacet(), qh_setaddnth(), qh_setcheck(), qh_setdelnth(), qh_setdelnthsorted(), qh_setnew_delnthsorted(), qh_setreplace(), qh_setsize(), qh_settruncate(), and qh_setzero(). 

01015                                                     {
01016   int size, k;
01017 
01018   if (!set)
01019     fprintf (fp, "%s set is null\n", string);
01020   else {
01021     SETreturnsize_(set, size);
01022     fprintf (fp, "%s set=%p maxsize=%d size=%d elems=",
01023              string, set, set->maxsize, size);
01024     if (size > set->maxsize)
01025       size= set->maxsize+1;
01026     for (k=0; k < size; k++)
01027       fprintf(fp, " %p", set->e[k].p);
01028     fprintf(fp, "\n");
01029   }
01030 } /* setprint */

void qh_setreplace (  setT *    set,
void *    oldelem,
void *    newelem
) 
 

Definition at line 1046 of file qset.c.

References qh_errexit(), qh_setprint(), qhmem_ERRqhull, and SETaddr_.

Referenced by qh_attachnewfacets(), qh_makenew_nonsimplicial(), qh_mergecycle_neighbors(), qh_mergefacet2d(), qh_mergeneighbors(), qh_mergesimplex(), and qh_mergevertex_neighbors(). 

01046                                                             {
01047   void **elemp;
01048   
01049   elemp= SETaddr_(set, void);
01050   while(*elemp != oldelem && *elemp)
01051     elemp++;
01052   if (*elemp)
01053     *elemp= newelem;
01054   else {
01055     fprintf (qhmem.ferr, "qhull internal error (qh_setreplace): elem %p not found in set\n",
01056        oldelem);
01057     qh_setprint (qhmem.ferr, "", set);
01058     qh_errexit (qhmem_ERRqhull, NULL, NULL);
01059   }
01060 } /* setreplace */

int qh_setsize (  setT *    set ) 
 

Definition at line 1076 of file qset.c.

References setT::maxsize, qh_errexit(), qh_setprint(), qhmem_ERRqhull, and SETsizeaddr_.

Referenced by qh_all_merges(), qh_check_bestdist(), qh_checkfacet(), qh_checkpolygon(), qh_checkvertex(), qh_collectstatistics(), qh_countfacets(), qh_degen_redundant_facet(), qh_degen_redundant_neighbors(), qh_deletevisible(), qh_facet3vertex(), qh_find_newvertex(), qh_findbestneighbor(), qh_getcenter(), qh_getmergeset(), qh_getmergeset_initial(), qh_initialvertices(), qh_markkeep(), qh_matchnewfacets(), qh_maxsimplex(), qh_maydropneighbor(), qh_merge_degenredundant(), qh_mergecycle_facets(), qh_mergefacet(), qh_mergevertices(), qh_nextfurthest(), qh_order_vertexneighbors(), qh_partitionvisible(), qh_point(), qh_pointfacet(), qh_pointvertex(), qh_printbegin(), qh_printextremes(), qh_printfacet3geom_nonsimplicial(), qh_printfacet3geom_points(), qh_printfacetheader(), qh_printfacetridges(), qh_printhyperplaneintersection(), qh_printpoints_out(), qh_printsummary(), qh_printvneighbors(), qh_printvoronoi(), qh_produce_output(), qh_qhull(), qh_remove_extravertices(), qh_rename_sharedvertex(), qh_renamevertex(), qh_setduplicate(), qh_settemp(), qh_settempfree(), qh_settemppop(), qh_settemppush(), qh_updatetested(), qh_vertexridges(), and qh_voronoi_center(). 

01076                           {
01077   int size, *sizep;
01078   
01079   if (!set)
01080     return (0);
01081   sizep= SETsizeaddr_(set);
01082   if ((size= *sizep)) {
01083     size--;
01084     if (size > set->maxsize) {
01085       fprintf (qhmem.ferr, "qhull internal error (qh_setsize): current set size %d is greater than maximum size %d\n",
01086                size, set->maxsize);
01087       qh_setprint (qhmem.ferr, "set: ", set);
01088       qh_errexit (qhmem_ERRqhull, NULL, NULL);
01089     }
01090   }else
01091     size= set->maxsize;
01092   return size;
01093 } /* setsize */

setT* qh_settemp (  int    setsize ) 
 

Definition at line 1110 of file qset.c.

References setT::maxsize, qh_setappend(), qh_setnew(), and qh_setsize().

Referenced by qh_basevertices(), qh_createsimplex(), qh_detvnorm(), qh_detvridge(), qh_detvridge3(), qh_facet3vertex(), qh_facetcenter(), qh_facetvertices(), qh_flippedmerges(), qh_forcedmerges(), qh_initialvertices(), qh_markkeep(), qh_maxmin(), qh_mergevertices(), qh_order_vertexneighbors(), qh_partitionall(), qh_pointfacet(), qh_pointvertex(), qh_postmerge(), qh_premerge(), qh_printextremes(), qh_printfacet3geom_nonsimplicial(), qh_printfacet3geom_points(), qh_printfacet3geom_simplicial(), qh_printfacet3math(), qh_printneighborhood(), qh_printpoints_out(), qh_printvneighbors(), qh_rename_sharedvertex(), qh_vertexridges(), and qh_voronoi_center(). 

01110                               {
01111   setT *newset;
01112   
01113   newset= qh_setnew (setsize);
01114   qh_setappend ((setT **)&qhmem.tempstack, newset);
01115   if (qhmem.IStracing >= 5)
01116     fprintf (qhmem.ferr, "qh_settemp: temp set %p of %d elements, depth %d\n",
01117        newset, newset->maxsize, qh_setsize ((setT*)qhmem.tempstack));
01118   return newset;
01119 } /* settemp */

void qh_settempfree (  setT **    set ) 
 

Definition at line 1138 of file qset.c.

References qh_errexit(), qh_setfree(), qh_setsize(), qh_settemppop(), qh_settemppush(), and qhmem_ERRqhull.

Referenced by qh_check_bestdist(), qh_check_maxout(), qh_checkfacet(), qh_createsimplex(), qh_detvnorm(), qh_eachvoronoi(), qh_facetcenter(), qh_find_newvertex(), qh_flippedmerges(), qh_forcedmerges(), qh_initbuild(), qh_initialvertices(), qh_markkeep(), qh_mergecycle_vneighbors(), qh_neighbor_intersections(), qh_partitionall(), qh_postmerge(), qh_premerge(), qh_printbegin(), qh_printextremes(), qh_printextremes_2d(), qh_printextremes_d(), qh_printfacet3geom_nonsimplicial(), qh_printfacet3geom_points(), qh_printfacet3geom_simplicial(), qh_printfacet3math(), qh_printfacet3vertex(), qh_printfacets(), qh_printneighborhood(), qh_printpoints_out(), qh_printvdiagram(), qh_printvertexlist(), qh_printvneighbors(), qh_printvoronoi(), qh_redundant_vertex(), qh_rename_sharedvertex(), qh_vertexintersect(), and qh_voronoi_center(). 

01138                                 {
01139   setT *stackedset;
01140 
01141   if (!*set)
01142     return;
01143   stackedset= qh_settemppop ();
01144   if (stackedset != *set) {
01145     qh_settemppush(stackedset);
01146     fprintf (qhmem.ferr, "qhull internal error (qh_settempfree): set %p (size %d) was not last temporary allocated (depth %d, set %p, size %d)\n",
01147              *set, qh_setsize(*set), qh_setsize((setT*)qhmem.tempstack)+1,
01148              stackedset, qh_setsize(stackedset));
01149     qh_errexit (qhmem_ERRqhull, NULL, NULL);
01150   }
01151   qh_setfree (set);
01152 } /* settempfree */

void qh_settempfree_all (  void    ) 
 

Definition at line 1165 of file qset.c.

References FOREACHset_, and qh_setfree().

Referenced by qh_freebuild(). 

01165                               {
01166   setT *set, **setp;
01167 
01168   FOREACHset_((setT *)qhmem.tempstack) 
01169     qh_setfree(&set);
01170   qh_setfree((setT **)&qhmem.tempstack);
01171 } /* settempfree_all */

setT* qh_settemppop (  void    ) 
 

Definition at line 1185 of file qset.c.

References qh_errexit(), qh_setdellast(), qh_setsize(), and qhmem_ERRqhull.

Referenced by qh_flippedmerges(), qh_forcedmerges(), qh_mergevertices(), qh_order_vertexneighbors(), and qh_settempfree(). 

01185                           {
01186   setT *stackedset;
01187   
01188   stackedset= (setT*)qh_setdellast((setT *)qhmem.tempstack);
01189   if (!stackedset) {
01190     fprintf (qhmem.ferr, "qhull internal error (qh_settemppop): pop from empty temporary stack\n");
01191     qh_errexit (qhmem_ERRqhull, NULL, NULL);
01192   }
01193   if (qhmem.IStracing >= 5)
01194     fprintf (qhmem.ferr, "qh_settemppop: depth %d temp set %p of %d elements\n",
01195        qh_setsize((setT*)qhmem.tempstack)+1, stackedset, qh_setsize(stackedset));
01196   return stackedset;
01197 } /* settemppop */

void qh_settemppush (  setT *    set ) 
 

Definition at line 1211 of file qset.c.

References qh_setappend(), and qh_setsize().

Referenced by qh_checkfacet(), qh_flippedmerges(), qh_forcedmerges(), qh_neighbor_intersections(), qh_rename_sharedvertex(), qh_settempfree(), and qh_vertexintersect(). 

01211                                {
01212   
01213   qh_setappend ((setT**)&qhmem.tempstack, set);
01214   if (qhmem.IStracing >= 5)
01215     fprintf (qhmem.ferr, "qh_settemppush: depth %d temp set %p of %d elements\n",
01216     qh_setsize((setT*)qhmem.tempstack), set, qh_setsize(set));
01217 } /* settemppush */

void qh_settruncate (  setT *    set,
int    size
) 
 

Definition at line 1233 of file qset.c.

References setT::e, setT::maxsize, setelemT::p, qh_errexit(), qh_setprint(), and qhmem_ERRqhull.

Referenced by qh_createsimplex(), qh_deletevisible(), qh_findbest(), qh_freebuild(), qh_mergecycle_ridges(), qh_partitionall(), and qh_setcompact(). 

01233                                           {
01234 
01235   if (size < 0 || size > set->maxsize) {
01236     fprintf (qhmem.ferr, "qhull internal error (qh_settruncate): size %d out of bounds for set:\n", size);
01237     qh_setprint (qhmem.ferr, "", set);
01238     qh_errexit (qhmem_ERRqhull, NULL, NULL);
01239   }
01240   set->e[set->maxsize].i= size+1;   /* maybe overwritten */
01241   set->e[size].p= NULL;
01242 } /* settruncate */

int qh_setunique (  setT **    set,
void *    elem
) 
 

Definition at line 1257 of file qset.c.

References qh_setappend(), and qh_setin().

Referenced by qh_maxsimplex(). 

01257                                           {
01258 
01259   if (!qh_setin (*set, elem)) {
01260     qh_setappend (set, elem);
01261     return 1;
01262   }
01263   return 0;
01264 } /* setunique */

void qh_setzero (  setT *    set,
int    index,
int    size
) 
 

Definition at line 1285 of file qset.c.

References setT::e, setT::maxsize, qh_errexit(), qh_setprint(), qhmem_ERRqhull, SETelemaddr_, and SETelemsize.

Referenced by qh_newhashtable(), qh_pointfacet(), qh_pointvertex(), qh_printextremes(), qh_printpoints_out(), and qh_printvneighbors(). 

01285                                                  {
01286   int count;
01287 
01288   if (index < 0 || index >= size || size > set->maxsize) {
01289     fprintf (qhmem.ferr, "qhull internal error (qh_setzero): index %d or size %d out of bounds for set:\n", index, size);
01290     qh_setprint (qhmem.ferr, "", set);
01291     qh_errexit (qhmem_ERRqhull, NULL, NULL);
01292   }
01293   set->e[set->maxsize].i=  size+1;  /* may be overwritten */
01294   count= size - index + 1;   /* +1 for NULL terminator */
01295   memset ((char *)SETelemaddr_(set, index, void), 0, count * SETelemsize);
01296 } /* setzero */
 
Powered by Plone

This site conforms to the following standards: