ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rhoptimize.c
(Generate patch)

Comparing ray/src/hd/rhoptimize.c (file contents):
Revision 3.4 by gwlarson, Mon Nov 9 17:11:40 1998 UTC vs.
Revision 3.12 by schorsch, Mon Jun 30 14:59:12 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1998 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Optimize holodeck for quick access.
6   *
7   *      11/4/98         Greg Ward Larson
8   */
9  
13 – #include "holo.h"
14 –
10   #include <signal.h>
11 + #include <string.h>
12 + #ifdef _WIN32
13 +  #include <process.h> /* getpid() */
14 + #endif
15  
16 + #include "holo.h"
17 +
18   #ifndef BKBSIZE
19   #define BKBSIZE         256             /* beam clump size (kilobytes) */
20   #endif
21  
22   char    *progname;
23   char    tempfile[128];
24 + int     dupchecking = 0;
25  
24 – extern char     *rindex();
25 – extern int      quit();
26   extern long     rhinitcopy();
27  
28  
# Line 35 | Line 35 | char   *argv[];
35          long    nextipos, lastopos, thisopos;
36  
37          progname = argv[0];
38 <        if (argc < 2 | argc > 3) {
39 <                fprintf(stderr, "Usage: %s input.hdk [output.hdk]\n", progname);
38 >        argv++; argc--;                 /* duplicate checking flag? */
39 >        if (argc > 1 && !strcmp(argv[0], "-u")) {
40 >                dupchecking++;
41 >                argv++; argc--;
42 >        }
43 >        if (argc < 1 | argc > 2) {
44 >                fprintf(stderr, "Usage: %s [-u] input.hdk [output.hdk]\n",
45 >                                progname);
46                  exit(1);
47          }
48 <        inpname = argv[1];
49 <        if (argc == 3)                  /* use given output file */
50 <                outname = argv[2];
48 >        inpname = argv[0];              /* get input file */
49 >        argv++; argc--;
50 >        if (argc == 1)                  /* use given output file */
51 >                outname = argv[0];
52          else {                          /* else use temporary file */
53                  if (access(inpname, R_OK|W_OK) < 0) {   /* check permissions */
54                          sprintf(errmsg, "cannot access \"%s\"", inpname);
55                          error(SYSTEM, errmsg);
56                  }
57                  strcpy(tempfile, inpname);
58 <                if ((outname = rindex(tempfile, '/')) != NULL)
58 >                if ((outname = strrchr(tempfile, '/')) != NULL)
59                          outname++;
60                  else
61                          outname = tempfile;
# Line 60 | Line 67 | char   *argv[];
67          lastopos = 0L;                  /* copy sections one by one */
68          while (nextipos != 0L) {
69                                          /* set input position; get next */
70 <                lseek(hdfd[0], nextipos, 0);
70 >                lseek(hdfd[0], (off_t)nextipos, 0);
71                  read(hdfd[0], (char *)&nextipos, sizeof(nextipos));
72                                          /* get output position; set last */
73 <                thisopos = lseek(hdfd[1], 0L, 2);
73 >                thisopos = lseek(hdfd[1], (off_t)0, 2);
74                  if (lastopos > 0L) {
75 <                        lseek(hdfd[1], lastopos, 0);
75 >                        lseek(hdfd[1], (off_t)lastopos, 0);
76                          write(hdfd[1], (char *)&thisopos, sizeof(thisopos));
77 <                        lseek(hdfd[1], 0L, 2);
77 >                        lseek(hdfd[1], (off_t)0, 2);
78                  }
79                  lastopos = thisopos;
80                  thisopos = 0L;          /* write place holder */
# Line 99 | Line 106 | char   *infn, *outfn;
106                  sprintf(errmsg, "cannot open \"%s\" for reading", infn);
107                  error(SYSTEM, errmsg);
108          }
109 +        if (access(outfn, F_OK) == 0) {
110 +                sprintf(errmsg, "output file \"%s\" already exists!", outfn);
111 +                error(USER, errmsg);
112 +        }
113          if ((outfp = fopen(outfn, "w+")) == NULL) {
114                  sprintf(errmsg, "cannot open \"%s\" for writing", outfn);
115                  error(SYSTEM, errmsg);
# Line 133 | Line 144 | char   *infn, *outfn;
144   }
145  
146  
147 < static HOLO     *hout;          /* output holodeck section */
147 > int
148 > nuniq(rva, n)                   /* sort unique rays to front of beam list */
149 > register RAYVAL *rva;
150 > int     n;
151 > {
152 >        register int    i, j;
153 >        RAYVAL  rtmp;
154  
155 +        for (j = 0; j < n; j++)
156 +                for (i = j+1; i < n; i++)
157 +                        if ( rva[i].d == rva[j].d &&
158 +                                        rva[i].r[0][0]==rva[j].r[0][0] &&
159 +                                        rva[i].r[0][1]==rva[j].r[0][1] &&
160 +                                        rva[i].r[1][0]==rva[j].r[1][0] &&
161 +                                        rva[i].r[1][1]==rva[j].r[1][1] ) {
162 +                                n--;            /* swap duplicate with end */
163 +                                copystruct(&rtmp, rva+n);
164 +                                copystruct(rva+n, rva+i);
165 +                                copystruct(rva+i, &rtmp);
166 +                                i--;            /* recheck one we swapped */
167 +                        }
168 +        return(n);
169 + }
170 +
171 +
172 + static BEAMI    *beamdir;
173 +
174   static int
175 < xferbeam(bp, hb)                /* transfer the given beam to hout and free */
176 < register BEAM   *bp;
141 < HDBEAMI *hb;
175 > bpcmp(b1p, b2p)                 /* compare beam positions on disk */
176 > int     *b1p, *b2p;
177   {
178 <        bcopy((char *)hdbray(bp), (char *)hdnewrays(hout,hb->b,bp->nrm),
179 <                        bp->nrm*sizeof(RAYVAL));
180 <        hdfreebeam(hb->h, hb->b);
178 >        register off_t  pdif = beamdir[*b1p].fo - beamdir[*b2p].fo;
179 >
180 >        if (pdif < 0L) return(-1);
181 >        return(pdif > 0L);
182 > }
183 >
184 > static HOLO     *hout;
185 >
186 > static int
187 > xferclump(hp, bq, nb)           /* transfer the given clump to hout and free */
188 > HOLO    *hp;
189 > int     *bq, nb;
190 > {
191 >        register int    i;
192 >        register BEAM   *bp;
193 >        int     n;
194 >
195 >        beamdir = hp->bi;               /* sort based on file position */
196 >        qsort((void *)bq, nb, sizeof(*bq), bpcmp);
197 >                                        /* transfer and free each beam */
198 >        for (i = 0; i < nb; i++) {
199 >                bp = hdgetbeam(hp, bq[i]);
200 >                DCHECK(bp==NULL, CONSISTENCY, "empty beam in xferclump");
201 >                n = dupchecking ? nuniq(hdbray(bp),bp->nrm) : bp->nrm;
202 >                memcpy((void *)hdnewrays(hout,bq[i],n),(void *)hdbray(bp),
203 >                                n*sizeof(RAYVAL));
204 >                hdfreebeam(hp, bq[i]);
205 >        }
206 >        hdfreebeam(hout, 0);            /* write & free clump */
207          return(0);
208   }
209  
# Line 155 | Line 216 | int    ifd, ofd;
216                                          /* create output section directory */
217          hout = hdinit(ofd, (HDGRID *)hinp);
218                                          /* clump the beams */
219 <        clumpbeams(hinp, 0, BKBSIZE*1024, xferbeam);
219 >        clumpbeams(hinp, 0, BKBSIZE*1024, xferclump);
220                                          /* clean up */
221          hddone(hinp);
222          hddone(hout);
223   }
224  
225  
226 + void
227   eputs(s)                        /* put error message to stderr */
228   register char  *s;
229   {
# Line 181 | Line 243 | register char  *s;
243   }
244  
245  
246 + void
247   quit(code)                      /* exit the program gracefully */
248   int     code;
249   {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines