pikl 0.2.7-x86-mswin32 → 0.2.8-x86-mswin32

data/ext/pikl/decrease/neuquant.h

@@ -0,0 +1,62 @@
+/* NeuQuant Neural-Net Quantization Algorithm Interface
+ * ----------------------------------------------------
+*/
+
+#include <stdio.h>
+
+/* For 256 colours, fixed arrays need 8kb, plus space for the image
+   ---------------------------------------------------------------- */
+
+/* four primes near 500 - assume no image has a length so large */
+/* that it is divisible by all four primes */
+#define prime1		499
+#define prime2		491
+#define prime3		487
+#define prime4		503
+
+#define minpicturebytes	(3*prime4)		/* minimum size for input image */
+
+
+/* Initialise network in range (0,0,0) to (255,255,255) and set parameters
+   ----------------------------------------------------------------------- */
+void initnet(unsigned char *thepic, int len, int sample);
+
+/* Unbias network to give byte values 0..255 and record position i to prepare for sort
+   ----------------------------------------------------------------------------------- */
+void unbiasnet();	/* can edit this function to do output of colour map */
+
+/* Output colour map
+   ----------------- */
+void writecolourmap(FILE *f);
+
+/* Insertion sort of network and building of netindex[0..255] (to do after unbias)
+   ------------------------------------------------------------------------------- */
+void inxbuild();
+
+/* Search for BGR values 0..255 (after net is unbiased) and return colour index
+   ---------------------------------------------------------------------------- */
+int inxsearch(register int b, register int g, register int r);
+
+/* Main Learning Loop
+   ------------------ */
+void learn();
+
+
+
+
+int neuReduce(unsigned char *RGBpic, int numcolors, long picsize, int sfactor,
+						unsigned char *QuantizedPicture, unsigned char *QuantizedPalette);
+
+
+
+/* Program Skeleton
+   ----------------
+	[select samplefac in range 1..30]
+	[read image from input file]
+	pic = (unsigned char*) malloc(3*width*height);
+	initnet(pic,3*width*height,samplefac);
+	learn();
+	unbiasnet();
+	[write output image header, using writecolourmap(f)]
+	inxbuild();
+	write output image using inxsearch(b,g,r)		*/

data/ext/pikl/decrease/wu.c

@@ -0,0 +1,447 @@
+/*
+       C Implementation of Wu's Color Quantizer (v2.0)
+       -- Xiaolin Wu.
+       From the Graphics Gems.
+
+       Memory hungry.
+
+       Some fixes and additional code by Benny.
+*/
+
+#include<stdio.h>
+#include<assert.h>
+#include<malloc.h>
+
+//#define NOINVERT        // RGB or BGR
+
+void            error(char *s);
+
+///* Externs: */
+//extern unsigned char            *Picture256;
+//extern unsigned char 		 QuantizedPalette[768];
+
+#define MAXCOLOR	256
+#define RED     	2
+#define	GREEN		1
+#define BLUE		0
+
+struct box {
+    int             r0;         /* min value, exclusive */
+    int             r1;         /* max value, inclusive */
+    int             g0;
+    int             g1;
+    int             b0;
+    int             b1;
+    int             vol;
+};
+
+/* Histogram is in elements 1..HISTSIZE along each axis,
+  element 0 is for base or marginal value.
+  NB: these must start out 0!	*/
+#define BOX   33
+long            wt[BOX][BOX][BOX],
+		mr[BOX][BOX][BOX],
+		mg[BOX][BOX][BOX],
+		mb[BOX][BOX][BOX];
+float           m2[BOX][BOX][BOX];
+
+int             ImageSize;           /* image size */
+int             PalSize;             /* color look-up table size */
+
+unsigned short  *Qadd;          // *must* be unsigned?
+unsigned char 	*TrueColorPic;
+
+/* build 3-D color histogram of counts, r/g/b, c^2 */
+static void Hist3d(long *vwt, long *vmr, long *vmg, long *vmb, float *m_2)
+{
+    int    ind,
+		    r,
+		    g,
+		    b;
+    int             inr,
+		    ing,
+		    inb,
+		    table[256];
+    long   i;
+
+    for (i = 0; i < 256; ++i)
+	table[i] = i * i;
+
+    for (i = 0; i < ImageSize; ++i) {
+	r = TrueColorPic[i*3  ];
+	g = TrueColorPic[i*3+1];
+	b = TrueColorPic[i*3+2];
+
+        inr = (r >> 3) + 1;
+	ing = (g >> 3) + 1;
+	inb = (b >> 3) + 1;
+	Qadd[i] = ind = (inr << 10) + (inr << 6) + inr + (ing << 5) + ing + inb;
+	/* [inr][ing][inb] */
+	++vwt[ind];
+	vmr[ind] += r;
+	vmg[ind] += g;
+	vmb[ind] += b;
+	m_2[ind] += (float) (table[r] + table[g] + table[b]);
+    }
+}
+
+/* We now convert histogram into moments so that we can rapidly calculate
+   the sums of the above quantities over any desired box. */
+static void Momt3d(long *vwt, long *vmr, long *vmg, long *vmb, float *m_2)
+{
+    unsigned short ind1,
+		    ind2;
+    unsigned char i,
+		    r,
+		    g,
+		    b;
+    long            line,
+		    line_r,
+		    line_g,
+		    line_b,
+		    area[BOX],
+		    area_r[BOX],
+		    area_g[BOX],
+		    area_b[BOX];
+    float           line2,
+		    area2[BOX];
+
+    for (r = 1; r <= 32; ++r) {
+	for (i = 0; i <= 32; ++i)
+	    area2[i] = area[i] = area_r[i] = area_g[i] = area_b[i] = 0;
+	for (g = 1; g <= 32; ++g) {
+	    line2 = line = line_r = line_g = line_b = 0;
+	    for (b = 1; b <= 32; ++b) {
+		ind1 = (r << 10) + (r << 6) + r + (g << 5) + g + b;
+		/* [r][g][b] */
+		line += vwt[ind1];
+		line_r += vmr[ind1];
+		line_g += vmg[ind1];
+		line_b += vmb[ind1];
+		line2 += m_2[ind1];
+		area[b] += line;
+		area_r[b] += line_r;
+		area_g[b] += line_g;
+		area_b[b] += line_b;
+		area2[b] += line2;
+		ind2 = ind1 - 1089; /* [r-1][g][b] */
+		vwt[ind1] = vwt[ind2] + area[b];
+		vmr[ind1] = vmr[ind2] + area_r[b];
+		vmg[ind1] = vmg[ind2] + area_g[b];
+		vmb[ind1] = vmb[ind2] + area_b[b];
+		m_2[ind1] = m_2[ind2] + area2[b];
+	    }
+	}
+    }
+}
+
+static long            Vol(struct box * cube, long mmt[BOX][BOX][BOX])
+{
+    return (mmt[cube->r1][cube->g1][cube->b1]
+	    - mmt[cube->r1][cube->g1][cube->b0]
+	    - mmt[cube->r1][cube->g0][cube->b1]
+	    + mmt[cube->r1][cube->g0][cube->b0]
+	    - mmt[cube->r0][cube->g1][cube->b1]
+	    + mmt[cube->r0][cube->g1][cube->b0]
+	    + mmt[cube->r0][cube->g0][cube->b1]
+	    - mmt[cube->r0][cube->g0][cube->b0]);
+}
+
+static long
+Bottom(struct box * cube, unsigned char dir, long mmt[BOX][BOX][BOX])
+{
+    switch (dir) {
+    case RED:
+	return (-mmt[cube->r0][cube->g1][cube->b1]
+		+ mmt[cube->r0][cube->g1][cube->b0]
+		+ mmt[cube->r0][cube->g0][cube->b1]
+		- mmt[cube->r0][cube->g0][cube->b0]);
+    case GREEN:
+	return (-mmt[cube->r1][cube->g0][cube->b1]
+		+ mmt[cube->r1][cube->g0][cube->b0]
+		+ mmt[cube->r0][cube->g0][cube->b1]
+		- mmt[cube->r0][cube->g0][cube->b0]);
+    case BLUE:
+	return (-mmt[cube->r1][cube->g1][cube->b0]
+		+ mmt[cube->r1][cube->g0][cube->b0]
+		+ mmt[cube->r0][cube->g1][cube->b0]
+		- mmt[cube->r0][cube->g0][cube->b0]);
+    }
+    error("error in Bottom()");
+    return 0;
+}
+
+static long
+Top(struct box * cube, unsigned char dir, int pos, long mmt[BOX][BOX][BOX])
+{
+    switch (dir) {
+    case RED:
+	return (mmt[pos][cube->g1][cube->b1]
+		- mmt[pos][cube->g1][cube->b0]
+		- mmt[pos][cube->g0][cube->b1]
+		+ mmt[pos][cube->g0][cube->b0]);
+    case GREEN:
+	return (mmt[cube->r1][pos][cube->b1]
+		- mmt[cube->r1][pos][cube->b0]
+		- mmt[cube->r0][pos][cube->b1]
+		+ mmt[cube->r0][pos][cube->b0]);
+    case BLUE:
+	return (mmt[cube->r1][cube->g1][pos]
+		- mmt[cube->r1][cube->g0][pos]
+		- mmt[cube->r0][cube->g1][pos]
+		+ mmt[cube->r0][cube->g0][pos]);
+    }
+    error("error in Top()");
+    return 0;
+}
+
+
+static float           Var(struct box * cube)
+{
+    float           dr,
+		    dg,
+                    db,
+		    xx;
+
+    dr = Vol(cube, mr);
+    dg = Vol(cube, mg);
+    db = Vol(cube, mb);
+    xx = m2[cube->r1][cube->g1][cube->b1]
+	- m2[cube->r1][cube->g1][cube->b0]
+	- m2[cube->r1][cube->g0][cube->b1]
+	+ m2[cube->r1][cube->g0][cube->b0]
+	- m2[cube->r0][cube->g1][cube->b1]
+	+ m2[cube->r0][cube->g1][cube->b0]
+	+ m2[cube->r0][cube->g0][cube->b1]
+	- m2[cube->r0][cube->g0][cube->b0];
+
+    return (xx - (dr * dr + dg * dg + db * db) / (float) Vol(cube, wt));
+}
+
+static float           Maximize(cube, dir, first, last, cut,
+			 whole_r, whole_g, whole_b, whole_w)
+    struct box     *cube;
+    unsigned char   dir;
+    int             first,
+		    last,
+		   *cut;
+    long            whole_r,
+                    whole_g,
+                    whole_b,
+		    whole_w;
+{
+    long   half_r,
+                    half_g,
+                    half_b,
+                    half_w;
+    long            base_r,
+                    base_g,
+                    base_b,
+		    base_w;
+    int    i;
+    float  temp,    max;
+
+    base_r = Bottom(cube, dir, mr);
+    base_g = Bottom(cube, dir, mg);
+    base_b = Bottom(cube, dir, mb);
+    base_w = Bottom(cube, dir, wt);
+    max = 0.0;
+    *cut = -1;
+    for (i = first; i < last; ++i) {
+	half_r = base_r + Top(cube, dir, i, mr);
+        half_g = base_g + Top(cube, dir, i, mg);
+        half_b = base_b + Top(cube, dir, i, mb);
+        half_w = base_w + Top(cube, dir, i, wt);
+        /* now half_x is sum over lower half of box, if split at i */
+        if (half_w == 0) {      /* subbox could be empty of pixels! */
+            continue;           /* never split into an empty box */
+        } else
+            temp = ((float) half_r * half_r + (float) half_g * half_g +
+		    (float) half_b * half_b) / half_w;
+
+	half_r = whole_r - half_r;
+        half_g = whole_g - half_g;
+	half_b = whole_b - half_b;
+        half_w = whole_w - half_w;
+        if (half_w == 0) {      /* subbox could be empty of pixels! */
+	    continue;           /* never split into an empty box */
+        } else
+            temp += ((float) half_r * half_r + (float) half_g * half_g +
+		     (float) half_b * half_b) / half_w;
+
+        if (temp > max) {
+            max = temp;
+	    *cut = i;
+	}
+    }
+    return (max);
+}
+
+static int             Cut(struct box * set1, struct box * set2)
+{
+    unsigned char   dir;
+    int             cutr,
+                    cutg,
+                    cutb;
+    float           maxr,
+		    maxg,
+                    maxb;
+    long            whole_r,
+		    whole_g,
+		    whole_b,
+                    whole_w;
+
+    whole_r = Vol(set1, mr);
+    whole_g = Vol(set1, mg);
+    whole_b = Vol(set1, mb);
+    whole_w = Vol(set1, wt);
+
+    maxr = Maximize(set1, RED, set1->r0 + 1, set1->r1, &cutr,
+		    whole_r, whole_g, whole_b, whole_w);
+    maxg = Maximize(set1, GREEN, set1->g0 + 1, set1->g1, &cutg,
+		    whole_r, whole_g, whole_b, whole_w);
+    maxb = Maximize(set1, BLUE, set1->b0 + 1, set1->b1, &cutb,
+                    whole_r, whole_g, whole_b, whole_w);
+
+    if ((maxr >= maxg) && (maxr >= maxb)) {
+	dir = RED;
+        if (cutr < 0)
+            return 0;           /* can't split the box */
+    } else if ((maxg >= maxr) && (maxg >= maxb))
+	dir = GREEN;
+    else
+        dir = BLUE;
+
+    set2->r1 = set1->r1;
+    set2->g1 = set1->g1;
+    set2->b1 = set1->b1;
+
+    switch (dir) {
+    case RED:
+        set2->r0 = set1->r1 = cutr;
+	set2->g0 = set1->g0;
+        set2->b0 = set1->b0;
+        break;
+    case GREEN:
+        set2->g0 = set1->g1 = cutg;
+	set2->r0 = set1->r0;
+        set2->b0 = set1->b0;
+        break;
+    case BLUE:
+	set2->b0 = set1->b1 = cutb;
+        set2->r0 = set1->r0;
+        set2->g0 = set1->g0;
+	break;
+    }
+    set1->vol = (set1->r1 - set1->r0) * (set1->g1 - set1->g0) * (set1->b1 - set1->b0);
+    set2->vol = (set2->r1 - set2->r0) * (set2->g1 - set2->g0) * (set2->b1 - set2->b0);
+    return 1;
+}
+
+static void            Mark(struct box * cube, int label, unsigned char *tag)
+{
+    int    r,		    g,		    b;
+    for (r = cube->r0 + 1; r <= cube->r1; ++r)
+	for (g = cube->g0 + 1; g <= cube->g1; ++g)
+	    for (b = cube->b0 + 1; b <= cube->b1; ++b)
+		tag[(r << 10) + (r << 6) + r + (g << 5) + g + b] = label;
+}
+
+#define WEIG	//>>2
+//int wuReduce(unsigned char *RGBpic, int numcolors, long picsize)
+int wuReduce(unsigned char *RGBpic, int numcolors, long picsize,
+			unsigned char *Picture256, unsigned char *QuantizedPalette)
+{
+    struct box      cube[MAXCOLOR];
+    unsigned char  *tag = 0;
+    float           vv[MAXCOLOR],
+		    temp = 0.;
+    long   	    i = 0,
+		    weight = 0;
+    int             next = 0;
+    int    	    j = 0,k = 0,l = 0;
+
+    /* input R,G,B components into TrueColorPic;
+       set ImageSize to width*height */
+    TrueColorPic = RGBpic;
+    ImageSize = picsize;
+    PalSize = numcolors;
+
+    for (j=0;j<BOX;j++)
+	for (k=0;k<BOX;k++)
+	    for (l=0;l<BOX;l++) {
+		wt[j][k][l] = 0;
+		mr[j][k][l] = 0;
+		mg[j][k][l] = 0;
+		mb[j][k][l] = 0;
+		m2[j][k][l] = 0.;
+	    }
+
+    Qadd = malloc(ImageSize * sizeof(short));
+    if (!Qadd)	error("Not enough mem for *Qadd");
+
+    Hist3d((long *)&wt, (long *)&mr, (long *)&mg, (long *)&mb, (float *)&m2);
+    Momt3d((long *)&wt, (long *)&mr, (long *)&mg, (long *)&mb, (float *)&m2);
+
+    cube[0].r0 = cube[0].g0 = cube[0].b0 = 0;
+    cube[0].r1 = cube[0].g1 = cube[0].b1 = 32;
+    next = 0;
+    for (i = 1; i < PalSize; ++i) {
+	if (Cut(&cube[next], &cube[i])) {
+	    vv[next] = (cube[next].vol > 1) ? Var(&cube[next]) : 0.0;
+	    vv[i] = (cube[i].vol > 1) ? Var(&cube[i]) : 0.0;
+	} else {
+	    vv[next] = 0.0;
+	    i--;
+	}
+	next = 0;
+	temp = vv[0];
+	for (k = 1; k <= i; ++k)
+	    if (vv[k] > temp) {
+		temp = vv[k];
+		next = k;
+	    }
+	if (temp <= 0.0) {
+	    PalSize = i + 1;
+	    break;
+	}
+    }
+
+    tag = malloc(BOX * BOX * BOX);
+    if (!tag)	error("Not enough mem for *tag");
+
+    for (k = 0; k < PalSize; ++k) {
+	Mark(&cube[k], k, tag);
+	weight = Vol(&cube[k], wt);
+	if (weight) {
+
+#ifdef NOINVERT
+	    QuantizedPalette[k*3+2] = (Vol(&cube[k], mr) / weight) WEIG;
+	    QuantizedPalette[k*3+0] = (Vol(&cube[k], mb) / weight) WEIG;
+#else
+	    QuantizedPalette[k*3+0] = (Vol(&cube[k], mr) / weight) WEIG;
+	    QuantizedPalette[k*3+2] = (Vol(&cube[k], mb) / weight) WEIG;
+#endif
+	    QuantizedPalette[k*3+1] = (Vol(&cube[k], mg) / weight) WEIG;
+	} else {
+	    QuantizedPalette[k*3+0] =
+	    QuantizedPalette[k*3+1] =
+	    QuantizedPalette[k*3+2] = 0;
+	}
+    }
+
+#ifdef VERBOSE
+    printf("ImageSize = %i\n", ImageSize);
+#endif
+    for (i = 0; i < ImageSize; i++) {
+        Picture256[i] = tag[Qadd[i]];
+        }
+
+    free(tag);
+    free(Qadd);
+
+    return 0;
+}
+/* Output:     QuantizedPalette[numcolors*3];
+	       Picture256[picsize];
+*/