src/gen/genblinds.c

#ifndef lint
static const char       RCSid[] = "$Id: genblinds.c,v 2.10 2003/06/08 12:03:09 schorsch Exp $";
#endif
/*
 *  genblind2.c - make some curved or flat venetian blinds.
 *
 *      Jean-Louis Scartezzini and Greg Ward
 * 
 *  parameters: 
 *              depth  -  depth of blinds
 *              width  -  width of slats
 *              height -  height of blinds
 *              nslats -  number of slats
 *              angle  -  blind incidence angle ( in degrees )
 *              rcurv  -  curvature radius of slats (up:>0;down:<0;flat:=0)
 */

#include  <stdio.h>
#include <stdlib.h>
#include  <math.h>
#include  <string.h>

#define  PI             3.14159265358979323846
#define  DELTA          10.  /*  MINIMAL SUSTAINED ANGLE IN DEGREES */

double  baseflat[4][3], baseblind[4][3][180];
double  A[3],X[3];
char  *material, *name;
double  height;
int  nslats,  nsurf;


static void makeflat(double w, double d, double a);
static void printslat(int n);
static void printhead(register int  ac, register char  **av);


void
makeflat(
        double w,
        double d,
        double a
)
{
        double  h;

        h = d*sin(a);
        d *= cos(a);
        baseflat[0][0] = 0.0;
        baseflat[0][1] = 0.0;
        baseflat[0][2] = 0.0;
        baseflat[1][0] = 0.0;
        baseflat[1][1] = w;
        baseflat[1][2] = 0.0;
        baseflat[2][0] = d;
        baseflat[2][1] = w;
        baseflat[2][2] = h;
        baseflat[3][0] = d;
        baseflat[3][1] = 0.0;
        baseflat[3][2] = h;

}


void
printslat(                      /* print slat # n */
        int  n
)
{
        register int  i, k;

        for (k=0; k < nsurf; k++)  {
                printf("\n%s polygon %s.%d.%d\n", material, name, n, k);
                printf("0\n0\n12\n");
                for (i = 0; i < 4; i++)
                        printf("\t%18.12g\t%18.12g\t%18.12g\n",
                                baseblind[i][0][k],
                                baseblind[i][1][k],
                                baseblind[i][2][k] + height*(n-.5)/nslats);
        }               
}


void
printhead(              /* print command header */
        register int  ac,
        register char  **av
)
{
        putchar('#');
        while (ac--) {
                putchar(' ');
                fputs(*av++, stdout);
        }
        putchar('\n');
}


int
main(
        int  argc,
        char  *argv[]
)
{
    double  width, delem, depth, rcurv = 0.0, angle;
    double  beta, gamma, theta, chi = 0;
    int     i, j, k, l;


    if (argc != 8 && argc != 10)
        goto userr;
    material = argv[1];
    name = argv[2];
    depth = atof(argv[3]);
    width = atof(argv[4]);
    height = atof(argv[5]);
    nslats  = atoi(argv[6]);
    angle = atof(argv[7]);
    if (argc == 10)
        if (!strcmp(argv[8], "-r"))
            rcurv = atof(argv[9]);
        else if (!strcmp(argv[8], "+r"))
            rcurv = -atof(argv[9]);
        else
            goto userr;

    /* CURVED BLIND CALCULATION */

    if (rcurv != 0) {

        /* BLINDS SUSTAINED ANGLE */

        theta = 2*asin(depth/(2*fabs(rcurv)));

        /* HOW MANY ELEMENTARY SURFACES SHOULD BE CALCULATED ? */

        nsurf = (int)(theta / ((PI/180.)*DELTA)) + 1;

        /* WHAT IS THE DEPTH OF THE ELEMENTARY SURFACES ? */

        delem = 2*fabs(rcurv)*sin((PI/180.)*(DELTA/2.));

        beta = (PI-theta)/2.;
        gamma = beta -((PI/180.)*angle);


        if (rcurv < 0) {
            A[0]=fabs(rcurv)*cos(gamma);
            A[0] *= -1;
            A[1]=0.;
            A[2]=fabs(rcurv)*sin(gamma);
        }
        if (rcurv > 0) {
            A[0]=fabs(rcurv)*cos(gamma+theta);
            A[1]=0.;
            A[2]=fabs(rcurv)*sin(gamma+theta);
            A[2] *= -1;
        }

        for (k=0; k < nsurf; k++) {
            if (rcurv < 0) {
                chi=(PI/180.)*((180.-DELTA)/2.) - (gamma+(k*(PI/180.)*DELTA));
            }
            if (rcurv > 0) {
                chi=(PI-(gamma+theta)+(k*(PI/180.)*DELTA))-(PI/180.)*   
                    ((180.-DELTA)/2.);
            }
            makeflat(width, delem, chi);
            if (rcurv < 0.) {
                X[0]=(-fabs(rcurv))*cos(gamma+(k*(PI/180.)*DELTA))-A[0];
                X[1]=0.;
                X[2]=fabs(rcurv)*sin(gamma+(k*(PI/180.)*DELTA))-A[2];
            }
            if (rcurv > 0.) {
                X[0]=fabs(rcurv)*cos(gamma+theta-(k*(PI/180.)*DELTA))-A[0];
                X[1]=0.;
                X[2]=(-fabs(rcurv))*sin(gamma+theta-(k*(PI/180.)*DELTA))-A[2];
            }

            for (i=0; i < 4; i++)  {
                for (j=0; j < 3; j++) {
                    baseblind[i][j][k] = baseflat[i][j]+X[j];
                } 
            }   
        }
    }

    /* FLAT BLINDS CALCULATION */

    if (rcurv == 0.) {

        nsurf=1;
        makeflat(width,depth,angle*(PI/180.));
        for (i=0; i < 4; i++) {
            for (j=0; j < 3; j++) {
                baseblind[i][j][0] = baseflat[i][j];
            }
        }
    }

    printhead(argc, argv);


    /* REPEAT THE BASIC CURVED OR FLAT SLAT TO GET THE OVERALL BLIND */

    for (l = 1; l <= nslats; l++)
        printslat(l);
    exit(0);
userr:
    fprintf(stderr,
            "Usage: %s mat name depth width height nslats angle [-r|+r rcurv]\n",
            argv[0]);
    exit(1);
}


Revision:	2.11
Committed:	Sun Nov 16 10:29:38 2003 UTC (21 years, 11 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R7P2, rad3R7P1, rad3R6, rad3R6P1
Changes since 2.10:	+96 -82 lines
Log Message:	Continued ANSIfication and reduced other compile warnings.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	2.11	static const char RCSid[] = "$Id: genblinds.c,v 2.10 2003/06/08 12:03:09 schorsch Exp $";
3	greg	1.1	#endif
4			/*
5			* genblind2.c - make some curved or flat venetian blinds.
6			*
7			* Jean-Louis Scartezzini and Greg Ward
8			*
9			* parameters:
10			* depth - depth of blinds
11			* width - width of slats
12			* height - height of blinds
13			* nslats - number of slats
14			* angle - blind incidence angle ( in degrees )
15			* rcurv - curvature radius of slats (up:>0;down:<0;flat:=0)
16			*/
17
18			#include <stdio.h>
19	greg	2.9	#include <stdlib.h>
20	greg	1.1	#include <math.h>
21	schorsch	2.10	#include <string.h>
22	greg	1.1
23	greg	2.7	#define PI 3.14159265358979323846
24			#define DELTA 10. /* MINIMAL SUSTAINED ANGLE IN DEGREES */
25	greg	1.1
26			double baseflat[4][3], baseblind[4][3][180];
27			double A[3],X[3];
28			char material, name;
29			double height;
30			int nslats, nsurf;
31	greg	2.6
32	greg	1.1
33	schorsch	2.11	static void makeflat(double w, double d, double a);
34			static void printslat(int n);
35			static void printhead(register int ac, register char **av);
36	schorsch	2.10
37	schorsch	2.11
38			void
39			makeflat(
40			double w,
41			double d,
42			double a
43			)
44	schorsch	2.10	{
45			double h;
46
47			h = d*sin(a);
48			d *= cos(a);
49			baseflat[0][0] = 0.0;
50			baseflat[0][1] = 0.0;
51			baseflat[0][2] = 0.0;
52			baseflat[1][0] = 0.0;
53			baseflat[1][1] = w;
54			baseflat[1][2] = 0.0;
55			baseflat[2][0] = d;
56			baseflat[2][1] = w;
57			baseflat[2][2] = h;
58			baseflat[3][0] = d;
59			baseflat[3][1] = 0.0;
60			baseflat[3][2] = h;
61
62			}
63
64
65	schorsch	2.11	void
66			printslat( /* print slat # n */
67			int n
68			)
69	schorsch	2.10	{
70			register int i, k;
71
72			for (k=0; k < nsurf; k++) {
73			printf("\n%s polygon %s.%d.%d\n", material, name, n, k);
74			printf("0\n0\n12\n");
75			for (i = 0; i < 4; i++)
76			printf("\t%18.12g\t%18.12g\t%18.12g\n",
77			baseblind[i][0][k],
78			baseblind[i][1][k],
79			baseblind[i][2][k] + height*(n-.5)/nslats);
80			}
81			}
82
83
84	schorsch	2.11	void
85			printhead( /* print command header */
86			register int ac,
87			register char **av
88			)
89	schorsch	2.10	{
90			putchar('#');
91			while (ac--) {
92			putchar(' ');
93			fputs(*av++, stdout);
94			}
95			putchar('\n');
96			}
97
98
99	schorsch	2.11	int
100			main(
101			int argc,
102			char *argv[]
103			)
104	greg	1.1	{
105	schorsch	2.11	double width, delem, depth, rcurv = 0.0, angle;
106			double beta, gamma, theta, chi = 0;
107			int i, j, k, l;
108
109
110			if (argc != 8 && argc != 10)
111			goto userr;
112			material = argv[1];
113			name = argv[2];
114			depth = atof(argv[3]);
115			width = atof(argv[4]);
116			height = atof(argv[5]);
117			nslats = atoi(argv[6]);
118			angle = atof(argv[7]);
119			if (argc == 10)
120			if (!strcmp(argv[8], "-r"))
121			rcurv = atof(argv[9]);
122			else if (!strcmp(argv[8], "+r"))
123			rcurv = -atof(argv[9]);
124			else
125			goto userr;
126	greg	1.1
127	schorsch	2.11	/* CURVED BLIND CALCULATION */
128	greg	1.1
129	schorsch	2.11	if (rcurv != 0) {
130	greg	1.1
131			/* BLINDS SUSTAINED ANGLE */
132
133			theta = 2asin(depth/(2fabs(rcurv)));
134
135	schorsch	2.11	/* HOW MANY ELEMENTARY SURFACES SHOULD BE CALCULATED ? */
136	greg	1.1
137	schorsch	2.10	nsurf = (int)(theta / ((PI/180.)*DELTA)) + 1;
138	greg	1.1
139			/* WHAT IS THE DEPTH OF THE ELEMENTARY SURFACES ? */
140
141			delem = 2fabs(rcurv)sin((PI/180.)*(DELTA/2.));
142
143			beta = (PI-theta)/2.;
144			gamma = beta -((PI/180.)*angle);
145
146
147
148			if (rcurv < 0) {
149	schorsch	2.11	A[0]=fabs(rcurv)*cos(gamma);
150			A[0] *= -1;
151			A[1]=0.;
152			A[2]=fabs(rcurv)*sin(gamma);
153	greg	1.1	}
154			if (rcurv > 0) {
155	schorsch	2.11	A[0]=fabs(rcurv)*cos(gamma+theta);
156			A[1]=0.;
157			A[2]=fabs(rcurv)*sin(gamma+theta);
158			A[2] *= -1;
159	greg	1.1	}
160
161			for (k=0; k < nsurf; k++) {
162	schorsch	2.11	if (rcurv < 0) {
163			chi=(PI/180.)((180.-DELTA)/2.) - (gamma+(k(PI/180.)*DELTA));
164			}
165			if (rcurv > 0) {
166			chi=(PI-(gamma+theta)+(k(PI/180.)DELTA))-(PI/180.)*
167			((180.-DELTA)/2.);
168			}
169			makeflat(width, delem, chi);
170			if (rcurv < 0.) {
171	greg	1.1	X[0]=(-fabs(rcurv))cos(gamma+(k(PI/180.)*DELTA))-A[0];
172			X[1]=0.;
173			X[2]=fabs(rcurv)sin(gamma+(k(PI/180.)*DELTA))-A[2];
174	schorsch	2.11	}
175			if (rcurv > 0.) {
176	greg	1.1	X[0]=fabs(rcurv)cos(gamma+theta-(k(PI/180.)*DELTA))-A[0];
177			X[1]=0.;
178			X[2]=(-fabs(rcurv))sin(gamma+theta-(k(PI/180.)*DELTA))-A[2];
179	schorsch	2.11	}
180
181			for (i=0; i < 4; i++) {
182			for (j=0; j < 3; j++) {
183			baseblind[i][j][k] = baseflat[i][j]+X[j];
184			}
185			}
186	greg	1.1	}
187	schorsch	2.11	}
188
189			/* FLAT BLINDS CALCULATION */
190	greg	1.1
191	schorsch	2.11	if (rcurv == 0.) {
192
193			nsurf=1;
194			makeflat(width,depth,angle*(PI/180.));
195			for (i=0; i < 4; i++) {
196			for (j=0; j < 3; j++) {
197			baseblind[i][j][0] = baseflat[i][j];
198			}
199	greg	1.1	}
200	schorsch	2.11	}
201	greg	1.1
202	schorsch	2.11	printhead(argc, argv);
203	greg	1.1
204
205	schorsch	2.11	/* REPEAT THE BASIC CURVED OR FLAT SLAT TO GET THE OVERALL BLIND */
206	greg	1.1
207	schorsch	2.11	for (l = 1; l <= nslats; l++)
208			printslat(l);
209			exit(0);
210	greg	1.1	userr:
211	schorsch	2.11	fprintf(stderr,
212			"Usage: %s mat name depth width height nslats angle [-r\|+r rcurv]\n",
213			argv[0]);
214			exit(1);
215	greg	1.1	}
216
217
218