src/px/pf2.c

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

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

/*
 *  pf2.c - routines used by pfilt.
 */

#include  <stdio.h>

#include  <math.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 */
long    npix;                   /* # pixels in average */

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;
        npix = 0;
        head = NULL;
}


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


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

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

                if (cbrt <= 0)
                        continue;

                if (avghot || cbrt < hotlvl) {
                        avgbrt += cbrt;
                        npix++;
                }
                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 */
{
        if (!npix) {
                fprintf(stderr, "%s: picture too dark or too bright\n",
                                progname);
                quit(1);
        }
        avgbrt /= (double)npix;

        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.4
Committed:	Wed Nov 9 15:04:52 1994 UTC (29 years, 5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.3:	+15 -10 lines
Log Message:	made pfilt more intelligent about averaging out zero pixels
#	User	Rev	Content
1	greg	2.4	/* Copyright (c) 1994 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
11			#include <stdio.h>
12
13	greg	2.3	#include <math.h>
14
15	greg	1.1	#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	2.4	long npix; /* # pixels in average */
43	greg	1.1
44	greg	2.2	typedef struct hotpix { /* structure for avgbrt pixels */
45	greg	1.1	struct hotpix next; / next in list */
46			COLOR val; /* pixel color */
47			short x, y; /* pixel position */
48			float slope; /* random slope for diffraction */
49			} HOTPIX;
50
51	greg	2.2	HOTPIX head; / head of avgbrt pixel list */
52	greg	1.1
53	greg	2.2	double sprdfact; /* computed spread factor */
54	greg	1.1
55
56			pass1init() /* prepare for first pass */
57			{
58			avgbrt = 0.0;
59	greg	2.4	npix = 0;
60	greg	1.1	head = NULL;
61			}
62
63
64			pass1default() /* for single pass */
65			{
66	greg	2.4	avgbrt = AVGLVL;
67			npix = 1;
68	greg	1.1	head = NULL;
69			}
70
71
72			pass1scan(scan, y) /* process first pass scanline */
73	greg	2.2	register COLOR *scan;
74	greg	1.1	int y;
75			{
76			extern char *malloc();
77	greg	2.2	double cbrt;
78	greg	1.1	register int x;
79	greg	2.2	register HOTPIX *hp;
80	greg	1.1
81			for (x = 0; x < xres; x++) {
82
83			cbrt = bright(scan[x]);
84
85	greg	2.4	if (cbrt <= 0)
86			continue;
87
88			if (avghot \|\| cbrt < hotlvl) {
89	greg	1.1	avgbrt += cbrt;
90	greg	2.4	npix++;
91			}
92	greg	1.1	if (npts && cbrt >= hotlvl) {
93			hp = (HOTPIX *)malloc(sizeof(HOTPIX));
94			if (hp == NULL) {
95			fprintf(stderr, "%s: out of memory\n",
96			progname);
97			quit(1);
98			}
99			copycolor(hp->val, scan[x]);
100			hp->x = x;
101			hp->y = y;
102			hp->slope = tan(PI*(0.5-(random()%npts+0.5)/npts));
103			hp->next = head;
104			head = hp;
105			}
106			}
107			}
108
109
110			pass2init() /* prepare for final pass */
111			{
112	greg	2.4	if (!npix) {
113			fprintf(stderr, "%s: picture too dark or too bright\n",
114			progname);
115	greg	1.1	quit(1);
116			}
117	greg	2.4	avgbrt /= (double)npix;
118	greg	1.1
119			scalecolor(exposure, AVGLVL/avgbrt);
120
121			sprdfact = spread / (hotlvl * bright(exposure))
122			* ((double)xresxres + (double)yresyres) / 4.0;
123			}
124
125
126			pass2scan(scan, y) /* process final pass scanline */
127	greg	2.2	register COLOR *scan;
128	greg	1.1	int y;
129			{
130			int xmin, xmax;
131			register int x;
132	greg	2.2	register HOTPIX *hp;
133	greg	1.1
134			for (hp = head; hp != NULL; hp = hp->next) {
135			if (hp->slope > FTINY) {
136			xmin = (y - hp->y - 0.5)/hp->slope + hp->x;
137			xmax = (y - hp->y + 0.5)/hp->slope + hp->x;
138			} else if (hp->slope < -FTINY) {
139			xmin = (y - hp->y + 0.5)/hp->slope + hp->x;
140			xmax = (y - hp->y - 0.5)/hp->slope + hp->x;
141			} else if (y == hp->y) {
142			xmin = 0;
143			xmax = xres-1;
144			} else {
145			xmin = 1;
146			xmax = 0;
147			}
148			if (xmin < 0)
149			xmin = 0;
150			if (xmax >= xres)
151			xmax = xres-1;
152			for (x = xmin; x <= xmax; x++)
153			starpoint(scan[x], x, y, hp);
154			}
155			for (x = 0; x < xres; x++)
156			multcolor(scan[x], exposure);
157			}
158
159
160			starpoint(fcol, x, y, hp) /* pixel is on the star's point */
161			COLOR fcol;
162			int x, y;
163	greg	2.2	register HOTPIX *hp;
164	greg	1.1	{
165			COLOR ctmp;
166	greg	2.2	double d2;
167	greg	1.1
168			d2 = (double)(x - hp->x)(x - hp->x) + (double)(y - hp->y)(y - hp->y);
169			if (d2 > sprdfact) {
170			d2 = sprdfact / d2;
171			if (d2 < FTINY)
172			return;
173			copycolor(ctmp, hp->val);
174			scalecolor(ctmp, d2);
175			addcolor(fcol, ctmp);
176			} else if (d2 > FTINY) {
177			addcolor(fcol, hp->val);
178			}
179			}