ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/px/neuclrtab.c

Comparing ray/src/px/neuclrtab.c (file contents):
Revision 2.6 by greg, Mon Nov 21 15:56:20 1994 UTC vs.
Revision 2.12 by greg, Mon Sep 19 02:23:58 2005 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1994 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Neural-Net quantization algorithm based on work of Anthony Dekker
6		*/
7
8	<	#include "standard.h"
8	>	#include "copyright.h"
9
10	<	#include "color.h"
10	>	#include <string.h>
11
12	+	#include "standard.h"
13	+	#include "color.h"
14		#include "random.h"
15	+	#include "clrtab.h"
16
17		#ifdef COMPAT_MODE
18		#define neu_init        new_histo
#	Line 28 | Line 28 | extern BYTE    clrtab[256][3];
28		static int      clrtabsiz;
29
30		#ifndef DEFSMPFAC
31	<	#ifdef SPEED
32	<	#define DEFSMPFAC       (240/SPEED+3)
33	<	#else
34	<	#define DEFSMPFAC       30
31	>	#define DEFSMPFAC       3
32		#endif
36	–	#endif
33
34		int     samplefac = DEFSMPFAC;  /* sampling factor */
35
#	Line 51 | Line 47 | static long    skipcount;
47
48		#define setskip(sp,n)   ((sp)[0]=(n)>>16,(sp)[1]=((n)>>8)&255,(sp)[2]=(n)&255)
49
50	+	static void initnet(void);
51	+	static void inxbuild(void);
52	+	static int inxsearch(int b, int g, int r);
53	+	static int contest(int b, int g, int r);
54	+	static void altersingle(int alpha, int i, int b, int g, int r);
55	+	static void alterneigh(int rad, int i, int b, int g, int r);
56	+	static void learn(void);
57	+	static void unbiasnet(void);
58	+	static void cpyclrtab(void);
59
60	<	neu_init(npixels)               /* initialize our sample array */
61	<	long    npixels;
60	>
61	>	extern int
62	>	neu_init(               /* initialize our sample array */
63	>	long    npixels
64	>	)
65		{
66		register int    nsleft;
67		register long   sv;
#	Line 90 | Line 98 | long   npixels;
98		}
99
100
101	<	neu_pixel(col)                  /* add pixel to our samples */
102	<	register BYTE   col[];
101	>	extern void
102	>	neu_pixel(                      /* add pixel to our samples */
103	>	register BYTE   col[]
104	>	)
105		{
106		if (!skipcount--) {
107		skipcount = nskip(cursamp);
#	Line 103 | Line 113 | register BYTE  col[];
113		}
114
115
116	<	neu_colrs(cs, n)                /* add a scanline to our samples */
117	<	register COLR   *cs;
118	<	register int    n;
116	>	extern void
117	>	neu_colrs(              /* add a scanline to our samples */
118	>	register COLR   *cs,
119	>	register int    n
120	>	)
121		{
122		while (n > skipcount) {
123		cs += skipcount;
#	Line 121 | Line 133 | register int   n;
133		}
134
135
136	<	neu_clrtab(ncolors)             /* make new color table using ncolors */
137	<	int     ncolors;
136	>	extern int
137	>	neu_clrtab(             /* make new color table using ncolors */
138	>	int     ncolors
139	>	)
140		{
141		clrtabsiz = ncolors;
142		if (clrtabsiz > 256) clrtabsiz = 256;
#	Line 132 | Line 146 | int    ncolors;
146		cpyclrtab();
147		inxbuild();
148		/* we're done with our samples */
149	<	free((char *)thesamples);
149	>	free((void *)thesamples);
150		/* reset dithering function */
151		neu_dith_colrs((BYTE *)NULL, (COLR *)NULL, 0);
152		/* return new color table size */
#	Line 140 | Line 154 | int    ncolors;
154		}
155
156
157	<	int
158	<	neu_map_pixel(col)              /* get pixel for color */
159	<	register BYTE   col[];
157	>	extern int
158	>	neu_map_pixel(          /* get pixel for color */
159	>	register BYTE   col[]
160	>	)
161		{
162		return(inxsearch(col[BLU],col[GRN],col[RED]));
163		}
164
165
166	<	neu_map_colrs(bs, cs, n)        /* convert a scanline to color index values */
167	<	register BYTE   *bs;
168	<	register COLR   *cs;
169	<	register int    n;
166	>	extern void
167	>	neu_map_colrs(  /* convert a scanline to color index values */
168	>	register BYTE   *bs,
169	>	register COLR   *cs,
170	>	register int    n
171	>	)
172		{
173		while (n-- > 0) {
174		*bs++ = inxsearch(cs[0][BLU],cs[0][GRN],cs[0][RED]);
#	Line 160 | Line 177 | register int   n;
177		}
178
179
180	<	neu_dith_colrs(bs, cs, n)       /* convert scanline to dithered index values */
181	<	register BYTE   *bs;
182	<	register COLR   *cs;
183	<	int     n;
180	>	extern void
181	>	neu_dith_colrs( /* convert scanline to dithered index values */
182	>	register BYTE   *bs,
183	>	register COLR   *cs,
184	>	int     n
185	>	)
186		{
187		static short    (*cerr)[3] = NULL;
188		static int      N = 0;
#	Line 172 | Line 191 | int    n;
191
192		if (n != N) {           /* get error propogation array */
193		if (N) {
194	<	free((char *)cerr);
194	>	free((void *)cerr);
195		cerr = NULL;
196		}
197		if (n)
#	Line 183 | Line 202 | int    n;
202		return;
203		}
204		N = n;
205	<	bzero((char *)cerr, 3*N*sizeof(short));
205	>	memset((char *)cerr, '\0', 3*N*sizeof(short));
206		}
207		err[0] = err[1] = err[2] = 0;
208		for (x = 0; x < n; x++) {
#	Line 257 | Line 276 | int    n;
276		#define true            1
277
278		/* network defs */
279	<	#define netsize         256                     /* number of colours - can change this */
279	>	#define netsize         clrtabsiz               /* number of colours - can change this */
280		#define maxnetpos       (netsize-1)
281		#define netbiasshift    4                       /* bias for colour values */
282		#define ncycles         100                     /* no. of learning cycles */
#	Line 272 | Line 291 | int    n;
291		#define betagamma       (intbias<<(gammashift-betashift))
292
293		/* defs for decreasing radius factor */
294	<	#define initrad         (netsize>>3)            /* for 256 cols, radius starts */
294	>	#define initrad         (256>>3)                /* for 256 cols, radius starts */
295		#define radiusbiasshift 6                       /* at 32.0 biased by 6 bits */
296		#define radiusbias      (((int) 1)<<radiusbiasshift)
297		#define initradius      (initrad*radiusbias)    /* and decreases by a */
#	Line 297 | Line 316 | int alphadec;                                  /* biased by 10 bits */
316		#define prime4          503
317
318		typedef int pixel[4];  /* BGRc */
319	<	pixel network[netsize];
319	>	pixel network[256];
320
321		int netindex[256];      /* for network lookup - really 256 */
322
323	<	int bias [netsize];     /* bias and freq arrays for learning */
324	<	int freq [netsize];
323	>	int bias [256];         /* bias and freq arrays for learning */
324	>	int freq [256];
325		int radpower[initrad];  /* radpower for precomputation */
326
327
328		/* initialise network in range (0,0,0) to (255,255,255) */
329
330	<	initnet()
330	>	static void
331	>	initnet(void)
332		{
333		register int i;
334		register int *p;
335
336	<	for (i=0; i<clrtabsiz; i++) {
336	>	for (i=0; i<netsize; i++) {
337		p = network[i];
338	<	p[0] = p[1] = p[2] = (i << (netbiasshift+8))/clrtabsiz;
339	<	freq[i] = intbias/clrtabsiz;  /* 1/clrtabsiz */
338	>	p[0] = p[1] = p[2] = (i << (netbiasshift+8))/netsize;
339	>	freq[i] = intbias/netsize;  /* 1/netsize */
340		bias[i] = 0;
341		}
342		}
#	Line 324 | Line 344 | initnet()
344
345		/* do after unbias - insertion sort of network and build netindex[0..255] */
346
347	<	inxbuild()
347	>	static void
348	>	inxbuild(void)
349		{
350		register int i,j,smallpos,smallval;
351		register int *p,*q;
#	Line 332 | Line 353 | inxbuild()
353
354		previouscol = 0;
355		startpos = 0;
356	<	for (i=0; i<clrtabsiz; i++) {
356	>	for (i=0; i<netsize; i++) {
357		p = network[i];
358		smallpos = i;
359		smallval = p[1];        /* index on g */
360	<	/* find smallest in i..clrtabsiz-1 */
361	<	for (j=i+1; j<clrtabsiz; j++) {
360	>	/* find smallest in i..netsize-1 */
361	>	for (j=i+1; j<netsize; j++) {
362		q = network[j];
363		if (q[1] < smallval) {  /* index on g */
364		smallpos = j;
#	Line 365 | Line 386 | inxbuild()
386		}
387
388
389	<	int inxsearch(b,g,r)  /* accepts real BGR values after net is unbiased */
390	<	register int b,g,r;
389	>	static int
390	>	inxsearch(  /* accepts real BGR values after net is unbiased */
391	>	register int b,
392	>	register int g,
393	>	register int r
394	>	)
395		{
396		register int i,j,dist,a,bestd;
397		register int *p;
#	Line 377 | Line 402 | register int b,g,r;
402		i = netindex[g]; /* index on g */
403		j = i-1;         /* start at netindex[g] and work outwards */
404
405	<	while ((i<clrtabsiz) || (j>=0)) {
406	<	if (i<clrtabsiz) {
405	>	while ((i<netsize) || (j>=0)) {
406	>	if (i<netsize) {
407		p = network[i];
408		dist = p[1] - g;        /* inx key */
409	<	if (dist >= bestd) i = clrtabsiz; /* stop iter */
409	>	if (dist >= bestd) i = netsize; /* stop iter */
410		else {
411		i++;
412		if (dist<0) dist = -dist;
#	Line 418 | Line 443 | register int b,g,r;
443		/* finds closest neuron (min dist) and updates freq */
444		/* finds best neuron (min dist-bias) and returns position */
445		/* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
446	<	/* bias[i] = gamma*((1/clrtabsiz)-freq[i]) */
446	>	/* bias[i] = gamma*((1/netsize)-freq[i]) */
447
448	<	int contest(b,g,r)      /* accepts biased BGR values */
449	<	register int b,g,r;
448	>	static int
449	>	contest(        /* accepts biased BGR values */
450	>	register int b,
451	>	register int g,
452	>	register int r
453	>	)
454		{
455		register int i,dist,a,biasdist,betafreq;
456		int bestpos,bestbiaspos,bestd,bestbiasd;
#	Line 434 | Line 463 | register int b,g,r;
463		p = bias;
464		f = freq;
465
466	<	for (i=0; i<clrtabsiz; i++) {
466	>	for (i=0; i<netsize; i++) {
467		n = network[i];
468		dist = n[0] - b;   if (dist<0) dist = -dist;
469		a = n[1] - g;   if (a<0) a = -a;
#	Line 456 | Line 485 | register int b,g,r;
485
486		/* move neuron i towards (b,g,r) by factor alpha */
487
488	<	altersingle(alpha,i,b,g,r)      /* accepts biased BGR values */
489	<	register int alpha,i,b,g,r;
488	>	static void
489	>	altersingle(    /* accepts biased BGR values */
490	>	register int alpha,
491	>	register int i,
492	>	register int b,
493	>	register int g,
494	>	register int r
495	>	)
496		{
497		register int *n;
498
#	Line 473 | Line 508 | register int alpha,i,b,g,r;
508		/* move neurons adjacent to i towards (b,g,r) by factor */
509		/* alpha*(1-((i-j)^2/[r]^2)) precomputed as radpower[|i-j|]*/
510
511	<	alterneigh(rad,i,b,g,r) /* accents biased BGR values */
512	<	int rad,i;
513	<	register int b,g,r;
511	>	static void
512	>	alterneigh(     /* accents biased BGR values */
513	>	int rad,
514	>	int i,
515	>	register int b,
516	>	register int g,
517	>	register int r
518	>	)
519		{
520		register int j,k,lo,hi,a;
521		register int *p, *q;
522
523		lo = i-rad;   if (lo<-1) lo= -1;
524	<	hi = i+rad;   if (hi>clrtabsiz) hi=clrtabsiz;
524	>	hi = i+rad;   if (hi>netsize) hi=netsize;
525
526		j = i+1;
527		k = i-1;
#	Line 510 | Line 550 | register int b,g,r;
550		}
551
552
553	<	learn()
553	>	static void
554	>	learn(void)
555		{
556		register int i,j,b,g,r;
557		int radius,rad,alpha,step,delta,samplepixels;
#	Line 568 | Line 609 | learn()
609		/* which can then be used for colour map */
610		/* and record position i to prepare for sort */
611
612	<	unbiasnet()
612	>	static void
613	>	unbiasnet(void)
614		{
615		int i,j;
616
617	<	for (i=0; i<clrtabsiz; i++) {
617	>	for (i=0; i<netsize; i++) {
618		for (j=0; j<3; j++)
619		network[i][j] >>= netbiasshift;
620		network[i][3] = i; /* record colour no */
#	Line 582 | Line 624 | unbiasnet()
624
625		/* Don't do this until the network has been unbiased (GW) */
626
627	<	static
628	<	cpyclrtab()
627	>	static void
628	>	cpyclrtab(void)
629		{
630		register int i,j,k;
631
632	<	for (j=0; j<clrtabsiz; j++) {
632	>	for (j=0; j<netsize; j++) {
633		k = network[j][3];
634		for (i = 0; i < 3; i++)
635		clrtab[k][i] = network[j][2-i];

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)