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

Comparing ray/src/rt/lookamb.c (file contents):
Revision 2.7 by greg, Sat Feb 22 02:07:28 2003 UTC vs.
Revision 2.12 by greg, Wed Apr 23 06:04:18 2014 UTC

# Line 5 | Line 5 | static const char      RCSid[] = "$Id$";
5   *  lookamb.c - program to examine ambient components.
6   */
7  
8 < /* ====================================================================
9 < * The Radiance Software License, Version 1.0
10 < *
11 < * Copyright (c) 1990 - 2002 The Regents of the University of California,
12 < * through Lawrence Berkeley National Laboratory.   All rights reserved.
13 < *
14 < * Redistribution and use in source and binary forms, with or without
15 < * modification, are permitted provided that the following conditions
16 < * are met:
17 < *
18 < * 1. Redistributions of source code must retain the above copyright
19 < *         notice, this list of conditions and the following disclaimer.
20 < *
21 < * 2. Redistributions in binary form must reproduce the above copyright
22 < *       notice, this list of conditions and the following disclaimer in
23 < *       the documentation and/or other materials provided with the
24 < *       distribution.
25 < *
26 < * 3. The end-user documentation included with the redistribution,
27 < *           if any, must include the following acknowledgment:
28 < *             "This product includes Radiance software
29 < *                 (http://radsite.lbl.gov/)
30 < *                 developed by the Lawrence Berkeley National Laboratory
31 < *               (http://www.lbl.gov/)."
32 < *       Alternately, this acknowledgment may appear in the software itself,
33 < *       if and wherever such third-party acknowledgments normally appear.
34 < *
35 < * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36 < *       and "The Regents of the University of California" must
37 < *       not be used to endorse or promote products derived from this
38 < *       software without prior written permission. For written
39 < *       permission, please contact [email protected].
40 < *
41 < * 5. Products derived from this software may not be called "Radiance",
42 < *       nor may "Radiance" appear in their name, without prior written
43 < *       permission of Lawrence Berkeley National Laboratory.
44 < *
45 < * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46 < * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47 < * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48 < * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49 < * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50 < * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51 < * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52 < * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53 < * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54 < * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55 < * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56 < * SUCH DAMAGE.
57 < * ====================================================================
58 < *
59 < * This software consists of voluntary contributions made by many
60 < * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
61 < * information on Lawrence Berkeley National Laboratory, please see
62 < * <http://www.lbl.gov/>.
63 < */
8 > #include "copyright.h"
9  
10 + #include  "platform.h"
11   #include  "ray.h"
66 –
12   #include  "ambient.h"
13 + #include  "resolu.h"
14  
15  
16   int  dataonly = 0;
# Line 73 | Line 19 | int  reverse = 0;
19  
20   AMBVAL  av;
21  
22 + #ifdef NEWAMB
23  
24 < main(argc, argv)                /* load ambient values from a file */
25 < int  argc;
26 < char  *argv[];
24 >
25 > static void
26 > lookamb(                        /* load & convert ambient values from a file */
27 >        FILE  *fp
28 > )
29   {
30 <        FILE  *fp;
82 <        int  i;
30 >        FVECT   norm, uvec;
31  
32 <        for (i = 1; i < argc; i++)
33 <                if (argv[i][0] == '-')
34 <                        switch (argv[i][1]) {
35 <                        case 'd':
36 <                                dataonly = 1;
37 <                                break;
38 <                        case 'r':
39 <                                reverse = 1;
40 <                                break;
41 <                        case 'h':
42 <                                header = 0;
43 <                                break;
44 <                        default:
45 <                                fprintf(stderr, "%s: unknown option '%s'\n",
98 <                                                argv[0], argv[i]);
99 <                                return(1);
100 <                        }
101 <                else
102 <                        break;
103 <
104 <        if (i >= argc)
105 <                fp = stdin;
106 <        else if ((fp = fopen(argv[i], "r")) == NULL) {
107 <                fprintf(stderr, "%s: file not found\n", argv[i]);
108 <                return(1);
109 <        }
110 <        if (reverse) {
111 <                if (header) {
112 <                        if (checkheader(fp, "ascii", stdout) < 0)
113 <                                goto formaterr;
32 >        while (readambval(&av, fp)) {
33 >                decodedir(norm, av.ndir);
34 >                decodedir(uvec, av.udir);
35 >                if (dataonly) {
36 >                        printf("%f\t%f\t%f\t", av.pos[0], av.pos[1], av.pos[2]);
37 >                        printf("%f\t%f\t%f\t", norm[0], norm[1], norm[2]);
38 >                        printf("%f\t%f\t%f\t", uvec[0], uvec[1], uvec[2]);
39 >                        printf("%d\t%f\t%f\t%f\t", av.lvl, av.weight,
40 >                                        av.rad[0], av.rad[1]);
41 >                        printf("%e\t%e\t%e\t", colval(av.val,RED),
42 >                                                colval(av.val,GRN),
43 >                                                colval(av.val,BLU));
44 >                        printf("%f\t%f\t", av.gpos[0], av.gpos[1]);
45 >                        printf("%f\t%f\n", av.gdir[0], av.gdir[1]);
46                  } else {
47 <                        newheader("RADIANCE", stdout);
48 <                        printargs(argc, argv, stdout);
47 >                        printf("\nPosition:\t%f\t%f\t%f\n", av.pos[0],
48 >                                        av.pos[1], av.pos[2]);
49 >                        printf("Normal:\t\t%f\t%f\t%f\n",
50 >                                        norm[0], norm[1], norm[2]);
51 >                        printf("Uvector:\t%f\t%f\t%f\n",
52 >                                        uvec[0], uvec[1], uvec[2]);
53 >                        printf("Lvl,Wt,UVrad:\t%d\t\t%f\t%f\t%f\n", av.lvl,
54 >                                        av.weight, av.rad[0], av.rad[1]);
55 >                        printf("Value:\t\t%e\t%e\t%e\n", colval(av.val,RED),
56 >                                        colval(av.val,GRN), colval(av.val,BLU));
57 >                        printf("Pos.Grad:\t%f\t%f\n", av.gpos[0], av.gpos[1]);
58 >                        printf("Dir.Grad:\t%f\t%f\n", av.gdir[0], av.gdir[1]);
59                  }
60 <                fputformat(AMBFMT, stdout);
61 <                putchar('\n');
120 < #ifdef MSDOS
121 <                setmode(fileno(stdout), O_BINARY);
122 < #endif
123 <                putambmagic(stdout);
124 <                writamb(fp);
125 <        } else {
126 < #ifdef MSDOS
127 <                setmode(fileno(fp), O_BINARY);
128 < #endif
129 <                if (checkheader(fp, AMBFMT, header ? stdout : (FILE *)NULL) < 0)
130 <                        goto formaterr;
131 <                if (!hasambmagic(fp))
132 <                        goto formaterr;
133 <                if (header) {
134 <                        fputformat("ascii", stdout);
135 <                        putchar('\n');
136 <                }
137 <                lookamb(fp);
60 >                if (ferror(stdout))
61 >                        exit(1);
62          }
139 –        fclose(fp);
140 –        return(0);
141 – formaterr:
142 –        fprintf(stderr, "%s: format error on input\n", argv[0]);
143 –        exit(1);
63   }
64  
65  
66 < void
67 < lookamb(fp)                     /* get ambient values from a file */
68 < FILE  *fp;
66 > static void
67 > writamb(                        /* write binary ambient values to stdout */
68 >        FILE  *fp
69 > )
70   {
71 +        FVECT   norm;
72 +
73 +        for ( ; ; ) {
74 +                if (!dataonly)
75 +                        fscanf(fp, "%*s");
76 +                if (fscanf(fp, "%f %f %f",
77 +                                &av.pos[0], &av.pos[1], &av.pos[2]) != 3)
78 +                        return;
79 +                if (!dataonly)
80 +                        fscanf(fp, "%*s");
81 +                if (fscanf(fp, FVFORMAT, &norm[0], &norm[1], &norm[2]) != 3)
82 +                        return;
83 +                av.ndir = encodedir(norm);
84 +                if (!dataonly)
85 +                        fscanf(fp, "%*s");
86 +                if (fscanf(fp, FVFORMAT, &norm[0], &norm[1], &norm[2]) != 3)
87 +                        return;
88 +                av.udir = encodedir(norm);
89 +                if (!dataonly)
90 +                        fscanf(fp, "%*s");
91 +                if (fscanf(fp, "%d %f %f %f", &av.lvl, &av.weight,
92 +                                &av.rad[0], &av.rad[1]) != 4)
93 +                        return;
94 +                if (!dataonly)
95 +                        fscanf(fp, "%*s");
96 +                if (fscanf(fp, "%f %f %f",
97 +                                &av.val[RED], &av.val[GRN], &av.val[BLU]) != 3)
98 +                        return;
99 +                if (!dataonly)
100 +                        fscanf(fp, "%*s");
101 +                if (fscanf(fp, "%f %f", &av.gpos[0], &av.gpos[1]) != 2)
102 +                        return;
103 +                if (!dataonly)
104 +                        fscanf(fp, "%*s");
105 +                if (fscanf(fp, "%f %f", &av.gdir[0], &av.gdir[1]) != 2)
106 +                        return;
107 +                av.next = NULL;
108 +                writambval(&av, stdout);
109 +                if (ferror(stdout))
110 +                        exit(1);
111 +        }
112 + }
113 +
114 +
115 + #else /* ! NEWAMB */
116 +
117 +
118 + static void
119 + lookamb(                        /* get ambient values from a file */
120 +        FILE  *fp
121 + )
122 + {
123          while (readambval(&av, fp)) {
124                  if (dataonly) {
125                          printf("%f\t%f\t%f\t", av.pos[0], av.pos[1], av.pos[2]);
# Line 180 | Line 152 | FILE  *fp;
152   }
153  
154  
155 < void
156 < writamb(fp)                     /* write binary ambient values */
157 < FILE  *fp;
155 > static void
156 > writamb(                        /* write binary ambient values */
157 >        FILE  *fp
158 > )
159   {
160          for ( ; ; ) {
161                  if (!dataonly)
# Line 220 | Line 193 | FILE  *fp;
193                  if (ferror(stdout))
194                          exit(1);
195          }
196 + }
197 +
198 +
199 + #endif  /* ! NEWAMB */
200 +
201 +
202 + int
203 + main(           /* load ambient values from a file */
204 +        int  argc,
205 +        char  *argv[]
206 + )
207 + {
208 +        FILE  *fp;
209 +        int  i;
210 +
211 +        for (i = 1; i < argc; i++)
212 +                if (argv[i][0] == '-')
213 +                        switch (argv[i][1]) {
214 +                        case 'd':
215 +                                dataonly = 1;
216 +                                break;
217 +                        case 'r':
218 +                                reverse = 1;
219 +                                break;
220 +                        case 'h':
221 +                                header = 0;
222 +                                break;
223 +                        default:
224 +                                fprintf(stderr, "%s: unknown option '%s'\n",
225 +                                                argv[0], argv[i]);
226 +                                return(1);
227 +                        }
228 +                else
229 +                        break;
230 +
231 +        if (i >= argc)
232 +                fp = stdin;
233 +        else if ((fp = fopen(argv[i], "r")) == NULL) {
234 +                fprintf(stderr, "%s: file not found\n", argv[i]);
235 +                return(1);
236 +        }
237 +        if (reverse) {
238 +                if (header) {
239 +                        if (checkheader(fp, "ascii", stdout) < 0)
240 +                                goto formaterr;
241 +                } else {
242 +                        newheader("RADIANCE", stdout);
243 +                        printargs(argc, argv, stdout);
244 +                }
245 +                fputformat(AMBFMT, stdout);
246 +                putchar('\n');
247 +                SET_FILE_BINARY(stdout);
248 +                putambmagic(stdout);
249 +                writamb(fp);
250 +        } else {
251 +                SET_FILE_BINARY(fp);
252 +                if (checkheader(fp, AMBFMT, header ? stdout : (FILE *)NULL) < 0)
253 +                        goto formaterr;
254 +                if (!hasambmagic(fp))
255 +                        goto formaterr;
256 +                if (header) {
257 +                        fputformat("ascii", stdout);
258 +                        putchar('\n');
259 +                }
260 +                lookamb(fp);
261 +        }
262 +        fclose(fp);
263 +        return(0);
264 + formaterr:
265 +        fprintf(stderr, "%s: format error on input\n", argv[0]);
266 +        exit(1);
267   }

Diff Legend

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