src/gen/genblinds.c

#ifndef lint
static const char       RCSid[] = "$Id: genblinds.c,v 2.14 2020/06/30 18:16:30 greg 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  "rtio.h"
#include  <stdlib.h>
#include  <math.h>

#ifndef PI
#define  PI             3.14159265358979323846
#endif
#define  DELTA          3.  /*  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);

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
)
{
        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);
        }               
}


int
main(
        int  argc,
        char  *argv[]
)
{
    double  width, delem, depth, rcurv = 0.0, mydelta, 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) + 0.99999);
        
        mydelta = (180./PI) * theta / nsurf;

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

        delem = 2.*fabs(rcurv)*sin((PI/180.)*(mydelta/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.-mydelta)/2.) - (gamma+(k*(PI/180.)*mydelta));
            }
            if (rcurv > 0) {
                chi=(PI-(gamma+theta)+(k*(PI/180.)*mydelta))-(PI/180.)*   
                    ((180.-mydelta)/2.);
            }
            makeflat(width, delem, chi);
            if (rcurv < 0.) {
                X[0]=(-fabs(rcurv))*cos(gamma+(k*(PI/180.)*mydelta))-A[0];
                X[1]=0.;
                X[2]=fabs(rcurv)*sin(gamma+(k*(PI/180.)*mydelta))-A[2];
            }
            if (rcurv > 0.) {
                X[0]=fabs(rcurv)*cos(gamma+theta-(k*(PI/180.)*mydelta))-A[0];
                X[1]=0.;
                X[2]=(-fabs(rcurv))*sin(gamma+theta-(k*(PI/180.)*mydelta))-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 */

    else {

        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];
            }
        }
    }

    fputs("# ", stdout);
    printargs(argc, argv, stdout);
 

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