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

Comparing src/hd/rhoptimize.c (file contents):
Revision 3.4 by gwlarson, Mon Nov 9 17:11:40 1998 UTC vs.
Revision 3.18 by schorsch, Thu Jan 1 11:21:55 2004 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 + #include <stdio.h>
13  
14 + #include "platform.h"
15 + #include "rterror.h"
16 + #include "resolu.h"
17 + #include "rtprocess.h" /* getpid() */
18 + #include "holo.h"
19 +
20   #ifndef BKBSIZE
21   #define BKBSIZE         256             /* beam clump size (kilobytes) */
22   #endif
23  
24   char    *progname;
25   char    tempfile[128];
26 + int     dupchecking = 0;
27  
28 < extern char     *rindex();
29 < extern int      quit();
30 < extern long     rhinitcopy();
28 > static long rhinitcopy(int hfd[2], char *infn, char *outfn);
29 > static int nuniq(RAYVAL *rva, int n);
30 > static int bpcmp(const void *b1p, const void *b2p);
31 > static int xferclump(HOLO *hp, int *bq, int nb);
32 > static void copysect(int ifd, int ofd);
33  
34  
35 < main(argc, argv)
36 < int     argc;
37 < char    *argv[];
35 > int
36 > main(
37 >        int     argc,
38 >        char    *argv[]
39 > )
40   {
41          char    *inpname, *outname;
42          int     hdfd[2];
43          long    nextipos, lastopos, thisopos;
44  
45          progname = argv[0];
46 <        if (argc < 2 | argc > 3) {
47 <                fprintf(stderr, "Usage: %s input.hdk [output.hdk]\n", progname);
46 >        argv++; argc--;                 /* duplicate checking flag? */
47 >        if (argc > 1 && !strcmp(argv[0], "-u")) {
48 >                dupchecking++;
49 >                argv++; argc--;
50 >        }
51 >        if ((argc < 1) | (argc > 2)) {
52 >                fprintf(stderr, "Usage: %s [-u] input.hdk [output.hdk]\n",
53 >                                progname);
54                  exit(1);
55          }
56 <        inpname = argv[1];
57 <        if (argc == 3)                  /* use given output file */
58 <                outname = argv[2];
56 >        inpname = argv[0];              /* get input file */
57 >        argv++; argc--;
58 >        if (argc == 1)                  /* use given output file */
59 >                outname = argv[0];
60          else {                          /* else use temporary file */
61                  if (access(inpname, R_OK|W_OK) < 0) {   /* check permissions */
62                          sprintf(errmsg, "cannot access \"%s\"", inpname);
63                          error(SYSTEM, errmsg);
64                  }
65                  strcpy(tempfile, inpname);
66 <                if ((outname = rindex(tempfile, '/')) != NULL)
66 >                if ((outname = strrchr(tempfile, '/')) != NULL)
67                          outname++;
68                  else
69                          outname = tempfile;
# Line 60 | Line 75 | char   *argv[];
75          lastopos = 0L;                  /* copy sections one by one */
76          while (nextipos != 0L) {
77                                          /* set input position; get next */
78 <                lseek(hdfd[0], nextipos, 0);
78 >                lseek(hdfd[0], (off_t)nextipos, SEEK_SET);
79                  read(hdfd[0], (char *)&nextipos, sizeof(nextipos));
80                                          /* get output position; set last */
81 <                thisopos = lseek(hdfd[1], 0L, 2);
81 >                thisopos = lseek(hdfd[1], (off_t)0, SEEK_END);
82                  if (lastopos > 0L) {
83 <                        lseek(hdfd[1], lastopos, 0);
83 >                        lseek(hdfd[1], (off_t)lastopos, SEEK_SET);
84                          write(hdfd[1], (char *)&thisopos, sizeof(thisopos));
85 <                        lseek(hdfd[1], 0L, 2);
85 >                        lseek(hdfd[1], (off_t)0, SEEK_END);
86                  }
87                  lastopos = thisopos;
88                  thisopos = 0L;          /* write place holder */
# Line 83 | Line 98 | char   *argv[];
98                                  outname, inpname);
99                  error(SYSTEM, errmsg);
100          }
101 <        exit(0);
101 >        return 0;
102   }
103  
104  
105 < long
106 < rhinitcopy(hfd, infn, outfn)    /* open files and copy header */
107 < int     hfd[2];                 /* returned file descriptors */
108 < char    *infn, *outfn;
105 > static long
106 > rhinitcopy(     /* open files and copy header */
107 >        int     hfd[2],                 /* returned file descriptors */
108 >        char    *infn,
109 >        char    *outfn
110 > )
111   {
112          FILE    *infp, *outfp;
113          long    ifpos;
# Line 99 | Line 116 | char   *infn, *outfn;
116                  sprintf(errmsg, "cannot open \"%s\" for reading", infn);
117                  error(SYSTEM, errmsg);
118          }
119 +        if (access(outfn, F_OK) == 0) {
120 +                sprintf(errmsg, "output file \"%s\" already exists!", outfn);
121 +                error(USER, errmsg);
122 +        }
123          if ((outfp = fopen(outfn, "w+")) == NULL) {
124                  sprintf(errmsg, "cannot open \"%s\" for writing", outfn);
125                  error(SYSTEM, errmsg);
# Line 133 | Line 154 | char   *infn, *outfn;
154   }
155  
156  
157 < static HOLO     *hout;          /* output holodeck section */
157 > static int
158 > nuniq(                  /* sort unique rays to front of beam list */
159 >        register RAYVAL *rva,
160 >        int     n
161 > )
162 > {
163 >        register int    i, j;
164 >        RAYVAL  rtmp;
165  
166 +        for (j = 0; j < n; j++)
167 +                for (i = j+1; i < n; i++)
168 +                        if ( rva[i].d == rva[j].d &&
169 +                                        rva[i].r[0][0]==rva[j].r[0][0] &&
170 +                                        rva[i].r[0][1]==rva[j].r[0][1] &&
171 +                                        rva[i].r[1][0]==rva[j].r[1][0] &&
172 +                                        rva[i].r[1][1]==rva[j].r[1][1] ) {
173 +                                n--;            /* swap duplicate with end */
174 +                                rtmp = *(rva+n);
175 +                                *(rva+n) = *(rva+i);
176 +                                *(rva+i) = rtmp;
177 +                                i--;            /* recheck one we swapped */
178 +                        }
179 +        return(n);
180 + }
181 +
182 +
183 + static BEAMI    *beamdir;
184 +
185   static int
186 < xferbeam(bp, hb)                /* transfer the given beam to hout and free */
187 < register BEAM   *bp;
188 < HDBEAMI *hb;
186 > bpcmp(                  /* compare beam positions on disk */
187 >        const void      *b1p,
188 >        const void      *b2p
189 > )
190   {
191 <        bcopy((char *)hdbray(bp), (char *)hdnewrays(hout,hb->b,bp->nrm),
192 <                        bp->nrm*sizeof(RAYVAL));
193 <        hdfreebeam(hb->h, hb->b);
191 >        register off_t  pdif = beamdir[*(int*)b1p].fo - beamdir[*(int*)b2p].fo;
192 >
193 >        if (pdif < 0L) return(-1);
194 >        return(pdif > 0L);
195 > }
196 >
197 > static HOLO     *hout;
198 >
199 > static int
200 > xferclump(              /* transfer the given clump to hout and free */
201 >        HOLO    *hp,
202 >        int     *bq,
203 >        int     nb
204 > )
205 > {
206 >        register int    i;
207 >        register BEAM   *bp;
208 >        int     n;
209 >
210 >        beamdir = hp->bi;               /* sort based on file position */
211 >        qsort((void *)bq, nb, sizeof(*bq), bpcmp);
212 >                                        /* transfer and free each beam */
213 >        for (i = 0; i < nb; i++) {
214 >                bp = hdgetbeam(hp, bq[i]);
215 >                DCHECK(bp==NULL, CONSISTENCY, "empty beam in xferclump");
216 >                n = dupchecking ? nuniq(hdbray(bp),bp->nrm) : bp->nrm;
217 >                memcpy((void *)hdnewrays(hout,bq[i],n),(void *)hdbray(bp),
218 >                                n*sizeof(RAYVAL));
219 >                hdfreebeam(hp, bq[i]);
220 >        }
221 >        hdfreebeam(hout, 0);            /* write & free clump */
222          return(0);
223   }
224  
225 < copysect(ifd, ofd)              /* copy holodeck section from ifd to ofd */
226 < int     ifd, ofd;
225 > static void
226 > copysect(               /* copy holodeck section from ifd to ofd */
227 >        int     ifd,
228 >        int     ofd
229 > )
230   {
231          HOLO    *hinp;
232                                          /* load input section directory */
# Line 155 | Line 234 | int    ifd, ofd;
234                                          /* create output section directory */
235          hout = hdinit(ofd, (HDGRID *)hinp);
236                                          /* clump the beams */
237 <        clumpbeams(hinp, 0, BKBSIZE*1024, xferbeam);
237 >        clumpbeams(hinp, 0, BKBSIZE*1024, xferclump);
238                                          /* clean up */
239          hddone(hinp);
240          hddone(hout);
241   }
242  
243  
244 + void
245   eputs(s)                        /* put error message to stderr */
246   register char  *s;
247   {
# Line 181 | Line 261 | register char  *s;
261   }
262  
263  
264 + void
265   quit(code)                      /* exit the program gracefully */
266   int     code;
267   {

Diff Legend

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