src/px/pf2.c

#ifndef lint
static const char       RCSid[] = "$Id: pf2.c,v 2.9 2022/04/21 03:11:55 greg Exp $";
#endif
/*
 *  pf2.c - routines used by pfilt.
 */

#include  "pfilt.h"
#include  "random.h"

#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 */

static void starpoint(COLOR  fcol, int  x, int  y, HOTPIX        *hp);


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


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


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

        for (x = 0; x < xres; x++) {
        
                cbrt = (*ourbright)(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-(irandom(npts)+0.5)/npts));
                        hp->next = head;
                        head = hp;
                }
        }
}


void
pass2init(void)                 /* 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 * (*ourbright)(exposure))
                        * ((double)xres*xres + (double)yres*yres) / 4.0;
}


void
pass2scan(              /* process final pass scanline */
        COLOR   *scan,
        int  y
)
{
        int  xmin, xmax;
        int  x;
        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);
}


static void
starpoint(              /* pixel is on the star's point */
        COLOR  fcol,
        int  x,
        int  y,
        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.10
Committed:	Thu Dec 7 21:15:54 2023 UTC (16 months, 4 weeks ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.9:	+2 -11 lines
Log Message:	refactor: Cleaned up and simplified #include's
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.10	static const char RCSid[] = "$Id: pf2.c,v 2.9 2022/04/21 03:11:55 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* pf2.c - routines used by pfilt.
6			*/
7
8	greg	2.10	#include "pfilt.h"
9	greg	1.1	#include "random.h"
10
11	greg	2.2	#define AVGLVL 0.5 /* target mean brightness */
12	greg	1.1
13	greg	2.2	double avgbrt; /* average picture brightness */
14	greg	2.4	long npix; /* # pixels in average */
15	greg	1.1
16	greg	2.2	typedef struct hotpix { /* structure for avgbrt pixels */
17	greg	1.1	struct hotpix next; / next in list */
18			COLOR val; /* pixel color */
19			short x, y; /* pixel position */
20			float slope; /* random slope for diffraction */
21			} HOTPIX;
22
23	greg	2.2	HOTPIX head; / head of avgbrt pixel list */
24	greg	1.1
25	greg	2.2	double sprdfact; /* computed spread factor */
26	greg	1.1
27	schorsch	2.7	static void starpoint(COLOR fcol, int x, int y, HOTPIX *hp);
28
29	greg	1.1
30	greg	2.8	void
31	schorsch	2.7	pass1init(void) /* prepare for first pass */
32	greg	1.1	{
33			avgbrt = 0.0;
34	greg	2.4	npix = 0;
35	greg	1.1	head = NULL;
36			}
37
38
39	greg	2.8	void
40	schorsch	2.7	pass1default(void) /* for single pass */
41	greg	1.1	{
42	greg	2.4	avgbrt = AVGLVL;
43			npix = 1;
44	greg	1.1	head = NULL;
45			}
46
47
48	greg	2.8	void
49	schorsch	2.7	pass1scan( /* process first pass scanline */
50	greg	2.8	COLOR *scan,
51	schorsch	2.7	int y
52			)
53	greg	1.1	{
54	greg	2.2	double cbrt;
55	greg	2.8	int x;
56			HOTPIX *hp;
57	greg	1.1
58			for (x = 0; x < xres; x++) {
59
60	greg	2.5	cbrt = (*ourbright)(scan[x]);
61	greg	1.1
62	greg	2.4	if (cbrt <= 0)
63			continue;
64
65			if (avghot \|\| cbrt < hotlvl) {
66	greg	1.1	avgbrt += cbrt;
67	greg	2.4	npix++;
68			}
69	greg	1.1	if (npts && cbrt >= hotlvl) {
70			hp = (HOTPIX *)malloc(sizeof(HOTPIX));
71			if (hp == NULL) {
72			fprintf(stderr, "%s: out of memory\n",
73			progname);
74			quit(1);
75			}
76			copycolor(hp->val, scan[x]);
77			hp->x = x;
78			hp->y = y;
79	greg	2.9	hp->slope = tan(PI*(0.5-(irandom(npts)+0.5)/npts));
80	greg	1.1	hp->next = head;
81			head = hp;
82			}
83			}
84			}
85
86
87	greg	2.8	void
88	schorsch	2.7	pass2init(void) /* prepare for final pass */
89	greg	1.1	{
90	greg	2.4	if (!npix) {
91			fprintf(stderr, "%s: picture too dark or too bright\n",
92			progname);
93	greg	1.1	quit(1);
94			}
95	greg	2.4	avgbrt /= (double)npix;
96	greg	1.1
97			scalecolor(exposure, AVGLVL/avgbrt);
98
99	greg	2.5	sprdfact = spread / (hotlvl * (*ourbright)(exposure))
100	greg	1.1	* ((double)xresxres + (double)yresyres) / 4.0;
101			}
102
103
104	greg	2.8	void
105	schorsch	2.7	pass2scan( /* process final pass scanline */
106	greg	2.8	COLOR *scan,
107	schorsch	2.7	int y
108			)
109	greg	1.1	{
110			int xmin, xmax;
111	greg	2.8	int x;
112			HOTPIX *hp;
113	greg	1.1
114			for (hp = head; hp != NULL; hp = hp->next) {
115			if (hp->slope > FTINY) {
116			xmin = (y - hp->y - 0.5)/hp->slope + hp->x;
117			xmax = (y - hp->y + 0.5)/hp->slope + hp->x;
118			} else if (hp->slope < -FTINY) {
119			xmin = (y - hp->y + 0.5)/hp->slope + hp->x;
120			xmax = (y - hp->y - 0.5)/hp->slope + hp->x;
121			} else if (y == hp->y) {
122			xmin = 0;
123			xmax = xres-1;
124			} else {
125			xmin = 1;
126			xmax = 0;
127			}
128			if (xmin < 0)
129			xmin = 0;
130			if (xmax >= xres)
131			xmax = xres-1;
132			for (x = xmin; x <= xmax; x++)
133			starpoint(scan[x], x, y, hp);
134			}
135			for (x = 0; x < xres; x++)
136			multcolor(scan[x], exposure);
137			}
138
139
140	schorsch	2.7	static void
141			starpoint( /* pixel is on the star's point */
142			COLOR fcol,
143			int x,
144			int y,
145	greg	2.8	HOTPIX *hp
146	schorsch	2.7	)
147	greg	1.1	{
148			COLOR ctmp;
149	greg	2.2	double d2;
150	greg	1.1
151			d2 = (double)(x - hp->x)(x - hp->x) + (double)(y - hp->y)(y - hp->y);
152			if (d2 > sprdfact) {
153			d2 = sprdfact / d2;
154			if (d2 < FTINY)
155			return;
156			copycolor(ctmp, hp->val);
157			scalecolor(ctmp, d2);
158			addcolor(fcol, ctmp);
159			} else if (d2 > FTINY) {
160			addcolor(fcol, hp->val);
161			}
162			}