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

Comparing src/gen/gensurf.c (file contents):
Revision 2.6 by greg, Sat Feb 22 02:07:23 2003 UTC vs.
Revision 2.18 by greg, Thu Oct 18 03:59:54 2007 UTC

# Line 1 | Line 1
1   #ifndef lint
2 < static const char       RCSid[] = "$Id$";
2 > static const char RCSid[] = "$Id$";
3   #endif
4   /*
5   *  gensurf.c - program to generate functional surfaces
# Line 17 | Line 17 | static const char      RCSid[] = "$Id$";
17  
18   #include  "standard.h"
19  
20 + #include  "paths.h"
21 + #include  "resolu.h"
22 + #include  "rterror.h"
23 + #include  "calcomp.h"
24 +
25   char  XNAME[] =         "X`SYS";                /* x function name */
26   char  YNAME[] =         "Y`SYS";                /* y function name */
27   char  ZNAME[] =         "Z`SYS";                /* z function name */
# Line 25 | Line 30 | char  VNAME[] =        "valid";                /* valid vertex name */
30  
31   #define  ABS(x)         ((x)>=0 ? (x) : -(x))
32  
33 + #define  ZEROVECT(v)    (DOT(v,v) <= FTINY*FTINY)
34 +
35   #define  pvect(p)       printf(vformat, (p)[0], (p)[1], (p)[2])
36  
37 < char  vformat[] = "%15.9g %15.9g %15.9g\n";
37 > char  vformat[] = "%18.12g %18.12g %18.12g\n";
38   char  tsargs[] = "4 surf_dx surf_dy surf_dz surf.cal\n";
39   char  texname[] = "Phong";
40  
41   int  smooth = 0;                /* apply smoothing? */
42 + int  objout = 0;                /* output .OBJ format? */
43  
44   char  *modname, *surfname;
45  
# Line 42 | Line 50 | char  *modname, *surfname;
50   struct {
51          int     flags;                  /* data type */
52          short   m, n;                   /* number of s and t values */
53 <        FLOAT   *data;                  /* the data itself, s major sort */
53 >        RREAL   *data;                  /* the data itself, s major sort */
54   } datarec;                      /* our recorded data */
55  
56 + /* XXX this is redundant with rt/noise3.c, should go to a library */
57   double  l_hermite(), l_bezier(), l_bspline(), l_dataval();
49 – extern double  funvalue(), argument();
58  
59   typedef struct {
60 <        int  valid;     /* point is valid */
60 >        int  valid;     /* point is valid (vertex number) */
61          FVECT  p;       /* vertex position */
62          FVECT  n;       /* average normal */
63 +        RREAL  uv[2];   /* (u,v) position */
64   } POINT;
65  
66  
67 + void loaddata(char *file, int m, int n, int pointsize);
68 + double l_dataval(char *nam);
69 + void putobjrow(POINT *rp, int n);
70 + void putsquare(POINT *p0, POINT *p1, POINT *p2, POINT *p3);
71 + void comprow(double s, POINT *row, int siz);
72 + void compnorms(POINT *r0, POINT *r1, POINT *r2, int siz);
73 + int norminterp(FVECT resmat[4], POINT *p0, POINT *p1, POINT *p2, POINT *p3);
74 +
75 +
76 + int
77   main(argc, argv)
78   int  argc;
79   char  *argv[];
80   {
62 –        extern long     eclock;
81          POINT  *row0, *row1, *row2, *rp;
82          int  i, j, m, n;
83          char  stmp[256];
# Line 79 | Line 97 | char  *argv[];
97                          fcompile(argv[++i]);
98                  else if (!strcmp(argv[i], "-s"))
99                          smooth++;
100 +                else if (!strcmp(argv[i], "-o"))
101 +                        objout++;
102                  else
103                          goto userror;
104  
# Line 118 | Line 138 | char  *argv[];
138          }
139          row0++; row1++; row2++;
140                                                  /* print header */
141 <        printhead(argc, argv);
141 >        fputs("# ", stdout);
142 >        printargs(argc, argv, stdout);
143          eclock = 0;
144                                                  /* initialize */
145          comprow(-1.0/m, row0, n);
146          comprow(0.0, row1, n);
147          comprow(1.0/m, row2, n);
148          compnorms(row0, row1, row2, n);
149 +        if (objout) {
150 +                printf("\nusemtl %s\n\n", modname);
151 +                putobjrow(row1, n);
152 +        }
153                                                  /* for each row */
154          for (i = 0; i < m; i++) {
155                                                  /* compute next row */
# Line 134 | Line 159 | char  *argv[];
159                  row2 = rp;
160                  comprow((double)(i+2)/m, row2, n);
161                  compnorms(row0, row1, row2, n);
162 +                if (objout)
163 +                        putobjrow(row1, n);
164  
165                  for (j = 0; j < n; j++) {
166                          int  orient = (j & 1);
167                                                          /* put polygons */
168 <                        if (!(row0[j].valid & row1[j+1].valid))
168 >                        if (!(row0[j].valid && row1[j+1].valid))
169                                  orient = 1;
170 <                        else if (!(row1[j].valid & row0[j+1].valid))
170 >                        else if (!(row1[j].valid && row0[j+1].valid))
171                                  orient = 0;
172                          if (orient)
173                                  putsquare(&row0[j], &row1[j],
# Line 151 | Line 178 | char  *argv[];
178                  }
179          }
180  
181 <        quit(0);
181 >        return 0;
182  
183   userror:
184          fprintf(stderr, "Usage: %s material name ", argv[0]);
185 <        fprintf(stderr, "x(s,t) y(s,t) z(s,t) m n [-s][-e expr][-f file]\n");
186 <        quit(1);
185 >        fprintf(stderr, "x(s,t) y(s,t) z(s,t) m n [-s][-o][-e expr][-f file]\n");
186 >        return 1;
187   }
188  
189  
190 < loaddata(file, m, n, pointsize)         /* load point data from file */
191 < char  *file;
192 < int  m, n;
193 < int  pointsize;
190 > void
191 > loaddata(               /* load point data from file */
192 >        char  *file,
193 >        int  m,
194 >        int  n,
195 >        int  pointsize
196 > )
197   {
198          FILE  *fp;
199          char  word[64];
200          register int  size;
201 <        register FLOAT  *dp;
201 >        register RREAL  *dp;
202  
203          datarec.flags = HASBORDER;              /* assume border values */
204          datarec.m = m+1;
# Line 176 | Line 206 | int  pointsize;
206          size = datarec.m*datarec.n*pointsize;
207          if (pointsize == 3)
208                  datarec.flags |= TRIPLETS;
209 <        dp = (FLOAT *)malloc(size*sizeof(FLOAT));
209 >        dp = (RREAL *)malloc(size*sizeof(RREAL));
210          if ((datarec.data = dp) == NULL) {
211                  fputs("Out of memory\n", stderr);
212                  exit(1);
# Line 199 | Line 229 | int  pointsize;
229                  size--;
230          }
231          if (size == (m+n+1)*pointsize) {        /* no border after all */
232 <                dp = (FLOAT *)realloc((char *)datarec.data,
233 <                                m*n*pointsize*sizeof(FLOAT));
232 >                dp = (RREAL *)realloc((void *)datarec.data,
233 >                                m*n*pointsize*sizeof(RREAL));
234                  if (dp != NULL)
235                          datarec.data = dp;
236                  datarec.flags &= ~HASBORDER;
# Line 219 | Line 249 | int  pointsize;
249  
250  
251   double
252 < l_dataval(nam)                          /* return recorded data value */
253 < char  *nam;
252 > l_dataval(                              /* return recorded data value */
253 >        char  *nam
254 > )
255   {
256          double  u, v;
257          register int  i, j;
258 <        register FLOAT  *dp;
258 >        register RREAL  *dp;
259          double  d00, d01, d10, d11;
260                                                  /* compute coordinates */
261          u = argument(1); v = argument(2);
# Line 260 | Line 291 | char  *nam;
291   }
292  
293  
294 < putsquare(p0, p1, p2, p3)               /* put out a square */
295 < POINT  *p0, *p1, *p2, *p3;
294 > void
295 > putobjrow(                      /* output vertex row to .OBJ */
296 >        register POINT  *rp,
297 >        int  n
298 > )
299   {
300 +        static int      nverts = 0;
301 +
302 +        for ( ; n-- >= 0; rp++) {
303 +                if (!rp->valid)
304 +                        continue;
305 +                fputs("v ", stdout);
306 +                pvect(rp->p);
307 +                if (smooth && !ZEROVECT(rp->n))
308 +                        printf("\tvn %.9g %.9g %.9g\n",
309 +                                        rp->n[0], rp->n[1], rp->n[2]);
310 +                printf("\tvt %.9g %.9g\n", rp->uv[0], rp->uv[1]);
311 +                rp->valid = ++nverts;
312 +        }
313 + }
314 +
315 +
316 + void
317 + putsquare(              /* put out a square */
318 +        POINT *p0,
319 +        POINT *p1,
320 +        POINT *p2,
321 +        POINT *p3
322 + )
323 + {
324          static int  nout = 0;
325          FVECT  norm[4];
326          int  axis;
327          FVECT  v1, v2, vc1, vc2;
328          int  ok1, ok2;
329                                          /* compute exact normals */
330 <        ok1 = (p0->valid & p1->valid & p2->valid);
330 >        ok1 = (p0->valid && p1->valid && p2->valid);
331          if (ok1) {
332 <                fvsum(v1, p1->p, p0->p, -1.0);
333 <                fvsum(v2, p2->p, p0->p, -1.0);
332 >                VSUB(v1, p1->p, p0->p);
333 >                VSUB(v2, p2->p, p0->p);
334                  fcross(vc1, v1, v2);
335                  ok1 = (normalize(vc1) != 0.0);
336          }
337 <        ok2 = (p1->valid & p2->valid & p3->valid);
337 >        ok2 = (p1->valid && p2->valid && p3->valid);
338          if (ok2) {
339 <                fvsum(v1, p2->p, p3->p, -1.0);
340 <                fvsum(v2, p1->p, p3->p, -1.0);
339 >                VSUB(v1, p2->p, p3->p);
340 >                VSUB(v2, p1->p, p3->p);
341                  fcross(vc2, v1, v2);
342                  ok2 = (normalize(vc2) != 0.0);
343          }
344          if (!(ok1 | ok2))
345                  return;
346 +        if (objout) {                   /* output .OBJ faces */
347 +                int     p0n=0, p1n=0, p2n=0, p3n=0;
348 +                if (smooth) {
349 +                        if (!ZEROVECT(p0->n))
350 +                                p0n = p0->valid;
351 +                        if (!ZEROVECT(p1->n))
352 +                                p1n = p1->valid;
353 +                        if (!ZEROVECT(p2->n))
354 +                                p2n = p2->valid;
355 +                        if (!ZEROVECT(p3->n))
356 +                                p3n = p3->valid;
357 +                }
358 +                if (ok1 & ok2 && fdot(vc1,vc2) >= 1.0-FTINY*FTINY) {
359 +                        printf("f %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d\n",
360 +                                        p0->valid, p0->valid, p0n,
361 +                                        p1->valid, p1->valid, p1n,
362 +                                        p3->valid, p3->valid, p3n,
363 +                                        p2->valid, p2->valid, p2n);
364 +                        return;
365 +                }
366 +                if (ok1)
367 +                        printf("f %d/%d/%d %d/%d/%d %d/%d/%d\n",
368 +                                        p0->valid, p0->valid, p0n,
369 +                                        p1->valid, p1->valid, p1n,
370 +                                        p2->valid, p2->valid, p2n);
371 +                if (ok2)
372 +                        printf("f %d/%d/%d %d/%d/%d %d/%d/%d\n",
373 +                                        p2->valid, p2->valid, p2n,
374 +                                        p1->valid, p1->valid, p1n,
375 +                                        p3->valid, p3->valid, p3n);
376 +                return;
377 +        }
378                                          /* compute normal interpolation */
379          axis = norminterp(norm, p0, p1, p2, p3);
380  
# Line 353 | Line 443 | POINT  *p0, *p1, *p2, *p3;
443   }
444  
445  
446 < comprow(s, row, siz)                    /* compute row of values */
447 < double  s;
448 < register POINT  *row;
449 < int  siz;
446 > void
447 > comprow(                        /* compute row of values */
448 >        double  s,
449 >        register POINT  *row,
450 >        int  siz
451 > )
452   {
453          double  st[2];
454          int  end;
# Line 379 | Line 471 | int  siz;
471                  if (checkvalid && funvalue(VNAME, 2, st) <= 0.0) {
472                          row[i].valid = 0;
473                          row[i].p[0] = row[i].p[1] = row[i].p[2] = 0.0;
474 +                        row[i].uv[0] = row[i].uv[1] = 0.0;
475                  } else {
476                          row[i].valid = 1;
477                          row[i].p[0] = funvalue(XNAME, 2, st);
478                          row[i].p[1] = funvalue(YNAME, 2, st);
479                          row[i].p[2] = funvalue(ZNAME, 2, st);
480 +                        row[i].uv[0] = st[0];
481 +                        row[i].uv[1] = st[1];
482                  }
483                  i++;
484          }
485   }
486  
487  
488 < compnorms(r0, r1, r2, siz)              /* compute row of averaged normals */
489 < register POINT  *r0, *r1, *r2;
490 < int  siz;
488 > void
489 > compnorms(              /* compute row of averaged normals */
490 >        register POINT  *r0,
491 >        register POINT  *r1,
492 >        register POINT  *r2,
493 >        int  siz
494 > )
495   {
496          FVECT  v1, v2;
497  
# Line 430 | Line 529 | int  siz;
529  
530  
531   int
532 < norminterp(resmat, p0, p1, p2, p3)      /* compute normal interpolation */
533 < register FVECT  resmat[4];
534 < POINT  *p0, *p1, *p2, *p3;
532 > norminterp(     /* compute normal interpolation */
533 >        register FVECT  resmat[4],
534 >        POINT  *p0,
535 >        POINT  *p1,
536 >        POINT  *p2,
537 >        POINT  *p3
538 > )
539   {
540   #define u  ((ax+1)%3)
541   #define v  ((ax+2)%3)
# Line 485 | Line 588 | POINT  *p0, *p1, *p2, *p3;
588   }
589  
590  
488 – void
489 – eputs(msg)
490 – char  *msg;
491 – {
492 –        fputs(msg, stderr);
493 – }
494 –
495 –
496 – void
497 – wputs(msg)
498 – char  *msg;
499 – {
500 –        eputs(msg);
501 – }
502 –
503 –
504 – void
505 – quit(code)
506 – int  code;
507 – {
508 –        exit(code);
509 – }
510 –
511 –
512 – printhead(ac, av)               /* print command header */
513 – register int  ac;
514 – register char  **av;
515 – {
516 –        putchar('#');
517 –        while (ac--) {
518 –                putchar(' ');
519 –                fputs(*av++, stdout);
520 –        }
521 –        putchar('\n');
522 – }
523 –
524 –
591   double
592 < l_hermite()                    
592 > l_hermite(char *nm)
593   {
594          double  t;
595          
# Line 536 | Line 602 | l_hermite()                    
602  
603  
604   double
605 < l_bezier()
605 > l_bezier(char *nm)
606   {
607          double  t;
608  
# Line 549 | Line 615 | l_bezier()
615  
616  
617   double
618 < l_bspline()
618 > l_bspline(char *nm)
619   {
620          double  t;
621  

Diff Legend

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