src/rt/lookamb.c

#ifndef lint
static const char       RCSid[] = "$Id: lookamb.c,v 2.16 2015/08/02 01:32:15 greg Exp $";
#endif
/*
 *  lookamb.c - program to examine ambient components.
 */

#include "copyright.h"

#include  "platform.h"
#include  "ray.h"
#include  "ambient.h"
#include  "resolu.h"


int  dataonly = 0;
int  header = 1;
int  reverse = 0;

AMBVAL  av;


static void
lookamb(                        /* load & convert ambient values from a file */
        FILE  *fp
)
{
        FVECT   norm, uvec;

        while (readambval(&av, fp)) {
                decodedir(norm, av.ndir);
                decodedir(uvec, av.udir);
                if (dataonly) {
                        printf("%f\t%f\t%f\t", av.pos[0], av.pos[1], av.pos[2]);
                        printf("%f\t%f\t%f\t", norm[0], norm[1], norm[2]);
                        printf("%f\t%f\t%f\t", uvec[0], uvec[1], uvec[2]);
                        printf("%d\t%f\t%f\t%f\t", av.lvl, av.weight,
                                        av.rad[0], av.rad[1]);
                        printf("%e\t%e\t%e\t", colval(av.val,RED),
                                                colval(av.val,GRN),
                                                colval(av.val,BLU));
                        printf("%f\t%f\t", av.gpos[0], av.gpos[1]);
                        printf("%f\t%f\t", av.gdir[0], av.gdir[1]);
                        printf("%u\n", av.corral);
                } else {
                        printf("Position:\t%f\t%f\t%f\n", av.pos[0],
                                        av.pos[1], av.pos[2]);
                        printf("Normal:\t\t%f\t%f\t%f\n",
                                        norm[0], norm[1], norm[2]);
                        printf("Uvector:\t%f\t%f\t%f\n",
                                        uvec[0], uvec[1], uvec[2]);
                        printf("Lvl,Wt,UVrad:\t%d\t\t%f\t%f\t%f\n", av.lvl,
                                        av.weight, av.rad[0], av.rad[1]);
                        printf("Value:\t\t%e\t%e\t%e\n", colval(av.val,RED),
                                        colval(av.val,GRN), colval(av.val,BLU));
                        printf("Pos.Grad:\t%f\t%f\n", av.gpos[0], av.gpos[1]);
                        printf("Dir.Grad:\t%f\t%f\n", av.gdir[0], av.gdir[1]);
                        printf("Corral:\t\t%8X\n\n", av.corral);
                }
                if (ferror(stdout))
                        exit(1);
        }
}


static void
writamb(                        /* write binary ambient values to stdout */
        FILE  *fp
)
{
        FVECT   norm;

        for ( ; ; ) {
                if (!dataonly)
                        fscanf(fp, "%*s");
                if (fscanf(fp, "%f %f %f",
                                &av.pos[0], &av.pos[1], &av.pos[2]) != 3)
                        return;
                if (!dataonly)
                        fscanf(fp, "%*s");
                if (fscanf(fp, FVFORMAT, &norm[0], &norm[1], &norm[2]) != 3)
                        return;
                av.ndir = encodedir(norm);
                if (!dataonly)
                        fscanf(fp, "%*s");
                if (fscanf(fp, FVFORMAT, &norm[0], &norm[1], &norm[2]) != 3)
                        return;
                av.udir = encodedir(norm);
                if (!dataonly)
                        fscanf(fp, "%*s");
                if (fscanf(fp, "%hd %f %f %f", &av.lvl, &av.weight,
                                &av.rad[0], &av.rad[1]) != 4)
                        return;
                if (!dataonly)
                        fscanf(fp, "%*s");
                if (fscanf(fp, "%f %f %f",
                                &av.val[RED], &av.val[GRN], &av.val[BLU]) != 3)
                        return;
                if (!dataonly)
                        fscanf(fp, "%*s");
                if (fscanf(fp, "%f %f", &av.gpos[0], &av.gpos[1]) != 2)
                        return;
                if (!dataonly)
                        fscanf(fp, "%*s");
                if (fscanf(fp, "%f %f", &av.gdir[0], &av.gdir[1]) != 2)
                        return;
                if (dataonly) {
                        if (fscanf(fp, "%u", &av.corral) != 1)
                                return;
                } else if (fscanf(fp, "%*s %X", &av.corral) != 1)
                        return;
                av.next = NULL;
                writambval(&av, stdout);
                if (ferror(stdout))
                        exit(1);
        }
}


int
main(           /* load ambient values from a file */
        int  argc,
        char  *argv[]
)
{
        FILE  *fp;
        int  i;

        for (i = 1; i < argc; i++)
                if (argv[i][0] == '-')
                        switch (argv[i][1]) {
                        case 'd':
                                dataonly = 1;
                                break;
                        case 'r':
                                reverse = 1;
                                break;
                        case 'h':
                                header = 0;
                                break;
                        default:
                                fprintf(stderr, "%s: unknown option '%s'\n",
                                                argv[0], argv[i]);
                                return(1);
                        }
                else
                        break;

        if (i >= argc)
                fp = stdin;
        else if ((fp = fopen(argv[i], "r")) == NULL) {
                fprintf(stderr, "%s: file not found\n", argv[i]);
                return(1);
        }
        if (reverse) {
                if (header) {
                        if (checkheader(fp, "ascii", stdout) < 0)
                                goto formaterr;
                } else {
                        newheader("RADIANCE", stdout);
                        printargs(argc, argv, stdout);
                }
                fputformat(AMBFMT, stdout);
                putchar('\n');
                SET_FILE_BINARY(stdout);
                putambmagic(stdout);
                writamb(fp);
        } else {
                SET_FILE_BINARY(fp);
                if (checkheader(fp, AMBFMT, header ? stdout : (FILE *)NULL) < 0)
                        goto formaterr;
                if (!hasambmagic(fp))
                        goto formaterr;
                if (header) {
                        fputformat("ascii", stdout);
                        putchar('\n');
                }
                lookamb(fp);
        }
        fclose(fp);
        return(0);
formaterr:
        fprintf(stderr, "%s: format error on input\n", argv[0]);
        exit(1);
}
Revision:	2.17
Committed:	Tue May 14 17:39:10 2019 UTC (5 years ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, rad5R3
Changes since 2.16:	+1 -90 lines
Log Message:	Stripped out code related to old (pre-Hessian) ambient calculation
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.17	static const char RCSid[] = "$Id: lookamb.c,v 2.16 2015/08/02 01:32:15 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* lookamb.c - program to examine ambient components.
6	greg	2.7	*/
7
8	greg	2.8	#include "copyright.h"
9	greg	1.1
10	schorsch	2.9	#include "platform.h"
11	greg	2.7	#include "ray.h"
12	greg	1.4	#include "ambient.h"
13	schorsch	2.10	#include "resolu.h"
14	greg	1.1
15
16			int dataonly = 0;
17	greg	2.3	int header = 1;
18	greg	1.1	int reverse = 0;
19
20			AMBVAL av;
21
22	greg	2.11
23			static void
24			lookamb( /* load & convert ambient values from a file */
25			FILE *fp
26	schorsch	2.10	)
27	greg	1.1	{
28	greg	2.11	FVECT norm, uvec;
29	greg	1.1
30	greg	2.11	while (readambval(&av, fp)) {
31			decodedir(norm, av.ndir);
32			decodedir(uvec, av.udir);
33			if (dataonly) {
34			printf("%f\t%f\t%f\t", av.pos[0], av.pos[1], av.pos[2]);
35			printf("%f\t%f\t%f\t", norm[0], norm[1], norm[2]);
36			printf("%f\t%f\t%f\t", uvec[0], uvec[1], uvec[2]);
37			printf("%d\t%f\t%f\t%f\t", av.lvl, av.weight,
38			av.rad[0], av.rad[1]);
39			printf("%e\t%e\t%e\t", colval(av.val,RED),
40			colval(av.val,GRN),
41			colval(av.val,BLU));
42			printf("%f\t%f\t", av.gpos[0], av.gpos[1]);
43	greg	2.13	printf("%f\t%f\t", av.gdir[0], av.gdir[1]);
44			printf("%u\n", av.corral);
45	greg	2.6	} else {
46	greg	2.14	printf("Position:\t%f\t%f\t%f\n", av.pos[0],
47	greg	2.11	av.pos[1], av.pos[2]);
48	greg	2.12	printf("Normal:\t\t%f\t%f\t%f\n",
49	greg	2.11	norm[0], norm[1], norm[2]);
50			printf("Uvector:\t%f\t%f\t%f\n",
51			uvec[0], uvec[1], uvec[2]);
52	greg	2.12	printf("Lvl,Wt,UVrad:\t%d\t\t%f\t%f\t%f\n", av.lvl,
53	greg	2.11	av.weight, av.rad[0], av.rad[1]);
54			printf("Value:\t\t%e\t%e\t%e\n", colval(av.val,RED),
55			colval(av.val,GRN), colval(av.val,BLU));
56			printf("Pos.Grad:\t%f\t%f\n", av.gpos[0], av.gpos[1]);
57			printf("Dir.Grad:\t%f\t%f\n", av.gdir[0], av.gdir[1]);
58	greg	2.14	printf("Corral:\t\t%8X\n\n", av.corral);
59	greg	2.6	}
60	greg	2.11	if (ferror(stdout))
61			exit(1);
62			}
63			}
64
65
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	greg	2.16	if (fscanf(fp, "%hd %f %f %f", &av.lvl, &av.weight,
92	greg	2.11	&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	greg	2.13	if (dataonly) {
108			if (fscanf(fp, "%u", &av.corral) != 1)
109			return;
110			} else if (fscanf(fp, "%*s %X", &av.corral) != 1)
111			return;
112	greg	2.11	av.next = NULL;
113			writambval(&av, stdout);
114			if (ferror(stdout))
115			exit(1);
116	greg	2.3	}
117	greg	1.1	}
118
119
120	greg	2.11	int
121			main( /* load ambient values from a file */
122			int argc,
123			char *argv[]
124			)
125			{
126			FILE *fp;
127			int i;
128
129			for (i = 1; i < argc; i++)
130			if (argv[i][0] == '-')
131			switch (argv[i][1]) {
132			case 'd':
133			dataonly = 1;
134			break;
135			case 'r':
136			reverse = 1;
137			break;
138			case 'h':
139			header = 0;
140			break;
141			default:
142			fprintf(stderr, "%s: unknown option '%s'\n",
143			argv[0], argv[i]);
144			return(1);
145			}
146			else
147			break;
148
149			if (i >= argc)
150			fp = stdin;
151			else if ((fp = fopen(argv[i], "r")) == NULL) {
152			fprintf(stderr, "%s: file not found\n", argv[i]);
153			return(1);
154			}
155			if (reverse) {
156			if (header) {
157			if (checkheader(fp, "ascii", stdout) < 0)
158			goto formaterr;
159			} else {
160			newheader("RADIANCE", stdout);
161			printargs(argc, argv, stdout);
162			}
163			fputformat(AMBFMT, stdout);
164			putchar('\n');
165			SET_FILE_BINARY(stdout);
166			putambmagic(stdout);
167			writamb(fp);
168			} else {
169			SET_FILE_BINARY(fp);
170			if (checkheader(fp, AMBFMT, header ? stdout : (FILE *)NULL) < 0)
171			goto formaterr;
172			if (!hasambmagic(fp))
173			goto formaterr;
174			if (header) {
175			fputformat("ascii", stdout);
176			putchar('\n');
177			}
178			lookamb(fp);
179			}
180			fclose(fp);
181			return(0);
182			formaterr:
183			fprintf(stderr, "%s: format error on input\n", argv[0]);
184			exit(1);
185			}