src/px/pf2.c

/* Copyright (c) 1992 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  pf2.c - routines used by pfilt.
 *
 *     10/3/85
 */

#include  <stdio.h>

#include  "random.h"

#include  "color.h"

#define  PI             3.14159265359

#define  FTINY          (1e-6)

extern int  nrows, ncols;       /* number of rows and columns for output */

extern int  xres, yres;         /* x and y resolution */

extern int  avghot;             /* true means average in avgbrt spots */

extern double  hotlvl;          /* brightness considered "hot" */

extern int  npts;               /* # of points for stars */

extern double  spread;          /* spread for star points */

extern char  *progname;

extern COLOR  exposure;         /* exposure for frame */

#define  AVGLVL         0.5     /* target mean brightness */

double  avgbrt;                 /* average picture brightness */

typedef struct  hotpix {        /* structure for avgbrt pixels */
        struct hotpix  *next;   /* next in list */
        COLOR  val;             /* pixel color */
        short  x, y;            /* pixel position */
        float  slope;           /* random slope for diffraction */
}  HOTPIX;

HOTPIX  *head;                  /* head of avgbrt pixel list */

double  sprdfact;               /* computed spread factor */


pass1init()                     /* prepare for first pass */
{
        avgbrt = 0.0;
        head = NULL;
}


pass1default()                  /* for single pass */
{
        avgbrt = AVGLVL * xres * yres;
        head = NULL;
}


pass1scan(scan, y)              /* process first pass scanline */
register COLOR  *scan;
int  y;
{
        extern char  *malloc();
        extern double  tan(), sqrt();
        double  cbrt;
        register int  x;
        register HOTPIX  *hp;

        for (x = 0; x < xres; x++) {
        
                cbrt = bright(scan[x]);

                if (avghot || cbrt < hotlvl)
                        avgbrt += cbrt;

                if (npts && cbrt >= hotlvl) {
                        hp = (HOTPIX *)malloc(sizeof(HOTPIX));
                        if (hp == NULL) {
                                fprintf(stderr, "%s: out of memory\n",
                                                progname);
                                quit(1);
                        }
                        copycolor(hp->val, scan[x]);
                        hp->x = x;
                        hp->y = y;
                        hp->slope = tan(PI*(0.5-(random()%npts+0.5)/npts));
                        hp->next = head;
                        head = hp;
                }
        }
}


pass2init()                     /* prepare for final pass */
{
        avgbrt /= (double)xres * yres;

        if (avgbrt <= FTINY) {
                fprintf(stderr, "%s: picture too dark\n", progname);
                quit(1);
        }

        scalecolor(exposure,  AVGLVL/avgbrt);
        
        sprdfact = spread / (hotlvl * bright(exposure))
                        * ((double)xres*xres + (double)yres*yres) / 4.0;
}


pass2scan(scan, y)              /* process final pass scanline */
register COLOR  *scan;
int  y;
{
        int  xmin, xmax;
        register int  x;
        register HOTPIX  *hp;
        
        for (hp = head; hp != NULL; hp = hp->next) {
                if (hp->slope > FTINY) {
                        xmin = (y - hp->y - 0.5)/hp->slope + hp->x;
                        xmax = (y - hp->y + 0.5)/hp->slope + hp->x;
                } else if (hp->slope < -FTINY) {
                        xmin = (y - hp->y + 0.5)/hp->slope + hp->x;
                        xmax = (y - hp->y - 0.5)/hp->slope + hp->x;
                } else if (y == hp->y) {
                        xmin = 0;
                        xmax = xres-1;
                } else {
                        xmin = 1;
                        xmax = 0;
                }
                if (xmin < 0)
                        xmin = 0;
                if (xmax >= xres)
                        xmax = xres-1;
                for (x = xmin; x <= xmax; x++)
                        starpoint(scan[x], x, y, hp);
        }
        for (x = 0; x < xres; x++)
                multcolor(scan[x], exposure);
}


starpoint(fcol, x, y, hp)               /* pixel is on the star's point */
COLOR  fcol;
int  x, y;
register HOTPIX  *hp;
{
        COLOR  ctmp;
        double  d2;
        
        d2 = (double)(x - hp->x)*(x - hp->x) + (double)(y - hp->y)*(y - hp->y);
        if (d2 > sprdfact) {
                d2 = sprdfact / d2;
                if (d2 < FTINY)
                        return;
                copycolor(ctmp, hp->val);
                scalecolor(ctmp, d2);
                addcolor(fcol, ctmp);
        } else if (d2 > FTINY) {
                addcolor(fcol, hp->val);
        }
}
Revision:	2.2
Committed:	Mon Sep 21 12:14:08 1992 UTC (31 years, 7 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.1:	+15 -15 lines
Log Message:	Changes for PC port
#	User	Rev	Content
1	greg	2.2	/* Copyright (c) 1992 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* pf2.c - routines used by pfilt.
9			*
10			* 10/3/85
11			*/
12
13			#include <stdio.h>
14
15			#include "random.h"
16
17			#include "color.h"
18
19	greg	2.2	#define PI 3.14159265359
20	greg	1.1
21	greg	2.2	#define FTINY (1e-6)
22	greg	1.1
23			extern int nrows, ncols; /* number of rows and columns for output */
24
25			extern int xres, yres; /* x and y resolution */
26
27			extern int avghot; /* true means average in avgbrt spots */
28
29			extern double hotlvl; /* brightness considered "hot" */
30
31			extern int npts; /* # of points for stars */
32
33			extern double spread; /* spread for star points */
34
35			extern char *progname;
36
37			extern COLOR exposure; /* exposure for frame */
38
39	greg	2.2	#define AVGLVL 0.5 /* target mean brightness */
40	greg	1.1
41	greg	2.2	double avgbrt; /* average picture brightness */
42	greg	1.1
43	greg	2.2	typedef struct hotpix { /* structure for avgbrt pixels */
44	greg	1.1	struct hotpix next; / next in list */
45			COLOR val; /* pixel color */
46			short x, y; /* pixel position */
47			float slope; /* random slope for diffraction */
48			} HOTPIX;
49
50	greg	2.2	HOTPIX head; / head of avgbrt pixel list */
51	greg	1.1
52	greg	2.2	double sprdfact; /* computed spread factor */
53	greg	1.1
54
55			pass1init() /* prepare for first pass */
56			{
57			avgbrt = 0.0;
58			head = NULL;
59			}
60
61
62			pass1default() /* for single pass */
63			{
64			avgbrt = AVGLVL * xres * yres;
65			head = NULL;
66			}
67
68
69			pass1scan(scan, y) /* process first pass scanline */
70	greg	2.2	register COLOR *scan;
71	greg	1.1	int y;
72			{
73			extern char *malloc();
74			extern double tan(), sqrt();
75	greg	2.2	double cbrt;
76	greg	1.1	register int x;
77	greg	2.2	register HOTPIX *hp;
78	greg	1.1
79			for (x = 0; x < xres; x++) {
80
81			cbrt = bright(scan[x]);
82
83			if (avghot \|\| cbrt < hotlvl)
84			avgbrt += cbrt;
85
86			if (npts && cbrt >= hotlvl) {
87			hp = (HOTPIX *)malloc(sizeof(HOTPIX));
88			if (hp == NULL) {
89			fprintf(stderr, "%s: out of memory\n",
90			progname);
91			quit(1);
92			}
93			copycolor(hp->val, scan[x]);
94			hp->x = x;
95			hp->y = y;
96			hp->slope = tan(PI*(0.5-(random()%npts+0.5)/npts));
97			hp->next = head;
98			head = hp;
99			}
100			}
101			}
102
103
104			pass2init() /* prepare for final pass */
105			{
106			avgbrt /= (double)xres * yres;
107
108			if (avgbrt <= FTINY) {
109			fprintf(stderr, "%s: picture too dark\n", progname);
110			quit(1);
111			}
112
113			scalecolor(exposure, AVGLVL/avgbrt);
114
115			sprdfact = spread / (hotlvl * bright(exposure))
116			* ((double)xresxres + (double)yresyres) / 4.0;
117			}
118
119
120			pass2scan(scan, y) /* process final pass scanline */
121	greg	2.2	register COLOR *scan;
122	greg	1.1	int y;
123			{
124			int xmin, xmax;
125			register int x;
126	greg	2.2	register HOTPIX *hp;
127	greg	1.1
128			for (hp = head; hp != NULL; hp = hp->next) {
129			if (hp->slope > FTINY) {
130			xmin = (y - hp->y - 0.5)/hp->slope + hp->x;
131			xmax = (y - hp->y + 0.5)/hp->slope + hp->x;
132			} else if (hp->slope < -FTINY) {
133			xmin = (y - hp->y + 0.5)/hp->slope + hp->x;
134			xmax = (y - hp->y - 0.5)/hp->slope + hp->x;
135			} else if (y == hp->y) {
136			xmin = 0;
137			xmax = xres-1;
138			} else {
139			xmin = 1;
140			xmax = 0;
141			}
142			if (xmin < 0)
143			xmin = 0;
144			if (xmax >= xres)
145			xmax = xres-1;
146			for (x = xmin; x <= xmax; x++)
147			starpoint(scan[x], x, y, hp);
148			}
149			for (x = 0; x < xres; x++)
150			multcolor(scan[x], exposure);
151			}
152
153
154			starpoint(fcol, x, y, hp) /* pixel is on the star's point */
155			COLOR fcol;
156			int x, y;
157	greg	2.2	register HOTPIX *hp;
158	greg	1.1	{
159			COLOR ctmp;
160	greg	2.2	double d2;
161	greg	1.1
162			d2 = (double)(x - hp->x)(x - hp->x) + (double)(y - hp->y)(y - hp->y);
163			if (d2 > sprdfact) {
164			d2 = sprdfact / d2;
165			if (d2 < FTINY)
166			return;
167			copycolor(ctmp, hp->val);
168			scalecolor(ctmp, d2);
169			addcolor(fcol, ctmp);
170			} else if (d2 > FTINY) {
171			addcolor(fcol, hp->val);
172			}
173			}