pikl 0.2.8-x86-mswin32 → 0.3.0-x86-mswin32

data/ext/pikl/decrease/median.h

@@ -1,7 +0,0 @@
-#ifndef _EXTRA_MEDIAN_
-#define _EXTRA_MEDIAN_
-
-void to_indexed(char*input,long ncolors,long dither,int width,int height,
-					unsigned char *Picture256, unsigned char *QuantizedPalette);
-
-#endif

data/ext/pikl/decrease/neuquan5.c

@@ -1,563 +0,0 @@
-/* NeuQuant Neural-Net Quantization Algorithm
- * ------------------------------------------
- *
- * Copyright (c) 1994 Anthony Dekker
- *
- * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994.
- * See "Kohonen neural networks for optimal colour quantization"
- * in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367.
- * for a discussion of the algorithm.
- * See also  http://members.ozemail.com.au/~dekker/NEUQUANT.HTML
- *
- * Any party obtaining a copy of these files from the author, directly or
- * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
- * world-wide, paid up, royalty-free, nonexclusive right and license to deal
- * in this software and documentation files (the "Software"), including without
- * limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons who receive
- * copies from any such party to do so, with the only requirement being
- * that this copyright notice remain intact.
- */
- 
-/* ------------------------------------------
- Code found on the Neuquant web page: http://acm.org/~dekker/NEUQUANT.HTML
- */
-
-//
-// Benny's additional stuff: v5
-// Weber fix: 9 Mar 00
-//
-// soezimaster additional
-// 2008.8.15
-//
-
-int colorsreq = 256;
-
-//-- soezimaster delete(function's call)
-//void            error(char *s);
-//extern unsigned char  *QuantizedPicture;
-//extern unsigned char  *QuantizedPalette;
-//----------------------------------------
-
-// number of colours used
-#define NETSIZE		256
-
-// 1 slower, 30 faster [1..30]
-//#define SFACTOR         15 // 1 15 30
-
-#include "neuquant.h"
-
-int netsize = NETSIZE;
-
-/* Network Definitions
-   ------------------- */
-
-#define maxnetpos	(netsize-1)
-#define netbiasshift	4			/* bias for colour values */
-#define ncycles		100			/* no. of learning cycles */
-
-/* defs for freq and bias */
-#define intbiasshift    16	/* bias for fractions */
-#define intbias		(((int) 1)<<intbiasshift)
-#define gammashift  	10	/* gamma = 1024 */
-#define gamma   	(((int) 1)<<gammashift)
-#define betashift  	10
-#define beta		(intbias>>betashift)	/* beta = 1/1024 */
-#define betagamma	(intbias<<(gammashift-betashift))
-
-/* defs for decreasing radius factor */
-#define INITRAD		(NETSIZE>>3)	/* for 256 cols, radius starts */
-#define initrad		(netsize>>3)	/* for 256 cols, radius starts */
-#define radiusbiasshift	6	/* at 32.0 biased by 6 bits */
-#define radiusbias	(((int) 1)<<radiusbiasshift)
-#define initradius	(initrad*radiusbias)	/* and decreases by a */
-#define radiusdec	30	/* factor of 1/30 each cycle */
-
-/* defs for decreasing alpha factor */
-#define alphabiasshift	10	/* alpha starts at 1.0 */
-#define initalpha	(((int) 1)<<alphabiasshift)
-int             alphadec;	/* biased by 10 bits */
-
-/* radbias and alpharadbias used for radpower calculation */
-#define radbiasshift	8
-#define radbias		(((int) 1)<<radbiasshift)
-#define alpharadbshift  (alphabiasshift+radbiasshift)
-#define alpharadbias    (((int) 1)<<alpharadbshift)
-
-
-/* Types and Global Variables
-   -------------------------- */
-
-static unsigned char *thepicture;	/* the input image itself */
-static int      lengthcount;	/* lengthcount = H*W*3 */
-static int      samplefac;	/* sampling factor 1..30 */
-
-typedef int     pixel[4];	/* BGRc */
-static pixel    network[NETSIZE];	/* the network itself */
-
-static int      netindex[256];	/* for network lookup - really 256 */
-
-static int      bias[NETSIZE];	/* bias and freq arrays for learning */
-static int      freq[NETSIZE];
-static int      radpower[INITRAD];	/* radpower for precomputation */
-
-
-/* Initialise network in range (0,0,0) to (255,255,255) and set parameters
-   ----------------------------------------------------------------------- */
-
-/*
-   void initnet(thepic,len,sample,output_size)
-   unsigned char *thepic;
-   int len;
-   int sample;
-   int output_size;
-   { */
-//static void initnet(unsigned char *thepic, int len,int sample)
-void initnet(unsigned char *thepic, int len,int sample)
-{
-     int    i, *p;
-
-/*
-   netsize = output_size;
-
-   network = (pixel *)malloc(netsize*sizeof(pixel));
-   bias = (int *)malloc(netsize*sizeof(int));
-   freq = (int *)malloc(netsize*sizeof(int));
-   radpower = (int *)malloc(initrad*sizeof(int));
-
-   if(!network || !bias || !freq || !radpower)exit(1);
- */
-
-    thepicture = thepic;
-    lengthcount = len;
-    samplefac = sample;
-
-    for (i = 0; i < netsize; i++) {
-	p = network[i];
-	p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
-	freq[i] = intbias / netsize;	/* 1/netsize */
-	bias[i] = 0;
-    }
-}
-
-
-/* Unbias network to give byte values 0..255 and record position i to prepare for sort
-   ----------------------------------------------------------------------------------- */
-
-//static void            unbiasnet()
-void            unbiasnet()
-{
-    int             i, j;
-
-    for (i = 0; i < netsize; i++) {
-	for (j = 0; j < 3; j++)
-	    network[i][j] >>= netbiasshift;
-	network[i][3] = i;	/* record colour no */
-    }
-}
-
-
-/* Output colour map
-   -----------------
-static void            writecolourmap(FILE *f)
-{
-    int             i, j;
-
-    for (i = 2; i >= 0; i--)
-	for (j = 0; j < netsize; j++)
-	    putc(network[j][i], f);
-}
-*/
-
-
-/* Insertion sort of network and building of netindex[0..255]
-   (to do after unbias)
-   ----------------------------------------------------------
-   --------------------- */
-
-//static void            inxbuild()
-void            inxbuild()
-{
-     int    i, j, smallpos, smallval;
-     int   *p, *q;
-    int             previouscol, startpos;
-
-    previouscol = 0;
-    startpos = 0;
-    for (i = 0; i < netsize; i++) {
-	p = network[i];
-	smallpos = i;
-	smallval = p[1];	/* index on g */
-	/* find smallest in i..netsize-1 */
-	for (j = i + 1; j < netsize; j++) {
-	    q = network[j];
-	    if (q[1] < smallval) {	/* index on g */
-		smallpos = j;
-		smallval = q[1];	/* index on g */
-	    }
-	}
-	q = network[smallpos];
-	/* swap p (i) and q (smallpos) entries */
-	if (i != smallpos) {
-	    j = q[0];
-	    q[0] = p[0];
-	    p[0] = j;
-	    j = q[1];
-	    q[1] = p[1];
-	    p[1] = j;
-	    j = q[2];
-	    q[2] = p[2];
-	    p[2] = j;
-	    j = q[3];
-	    q[3] = p[3];
-	    p[3] = j;
-	}
-	/* smallval entry is now in position i */
-	if (smallval != previouscol) {
-	    netindex[previouscol] = (startpos + i) >> 1;
-	    for (j = previouscol + 1; j < smallval; j++)
-		netindex[j] = i;
-	    previouscol = smallval;
-	    startpos = i;
-	}
-    }
-    netindex[previouscol] = (startpos + maxnetpos) >> 1;
-    for (j = previouscol + 1; j < 256; j++)
-	netindex[j] = maxnetpos;	/* really 256 */
-}
-
-
-/* Search for BGR values 0..255 (after net is unbiased) and
-   return colour index
-   --------------------------------------------------------
-   -------------------- */
-//static int             inxsearch(int    b, int g, int r)
-int             inxsearch(int    b, int g, int r)
-{
-    int    i, j, dist, a, bestd;
-    int   *p;
-    int             best;
-
-    bestd = 1000;		/* biggest possible dist is 256*3 */
-    best = -1;
-    i = netindex[g];		/* index on g */
-    j = i - 1;			/* start at netindex[g] and work outwards */
-
-    while ((i < netsize) || (j >= 0)) {
-	if (i < netsize) {
-	    p = network[i];
-	    dist = p[1] - g;	/* inx key */
-	    if (dist >= bestd)
-		i = netsize;	/* stop iter */
-	    else {
-		i++;
-		if (dist < 0)
-		    dist = -dist;
-		a = p[0] - b;
-		if (a < 0)
-		    a = -a;
-		dist += a;
-		if (dist < bestd) {
-		    a = p[2] - r;
-		    if (a < 0)
-			a = -a;
-		    dist += a;
-		    if (dist < bestd) {
-			bestd = dist;
-			best = p[3];
-		    }
-		}
-	    }
-	}
-/*        if (j >= 0) */   // not needed (Weber)
-	if (j >= 0){	//retreave(soezimaster)
-	    p = network[j];
-	    dist = g - p[1];	/* inx key - reverse dif */
-	    if (dist >= bestd)
-		j = -1;		/* stop iter */
-	    else {
-		j--;
-		if (dist < 0)
-		    dist = -dist;
-		a = p[0] - b;
-		if (a < 0)
-		    a = -a;
-		dist += a;
-		if (dist < bestd) {
-		    a = p[2] - r;
-		    if (a < 0)
-			a = -a;
-		    dist += a;
-		    if (dist < bestd) {
-				bestd = dist;
-				best = p[3];
-		    }
-		}
-	    }
-	}
-    }
-    return (best);
-}
-
-
-/* Search for biased BGR values
-   ---------------------------- */
-
-static int             contest(b, g, r)
- int    b, g, r;
-{
-    /* finds closest neuron (min dist) and updates freq */
-    /* finds best neuron (min dist-bias) and returns position */
-    /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
-    /* bias[i] = gamma*((1/netsize)-freq[i]) */
-
-    int    i, dist, a, biasdist, betafreq;
-    int    bestpos, bestbiaspos, bestd, bestbiasd;
-    int   *p, *f, *n;
-
-    bestd = ~(((int) 1) << 31);
-    bestbiasd = bestd;
-    bestpos = -1;
-    bestbiaspos = bestpos;
-    p = bias;
-    f = freq;
-
-    for (i = 0; i < netsize; i++) {
-	n = network[i];
-	dist = n[0] - b;
-	if (dist < 0)
-	    dist = -dist;
-	a = n[1] - g;
-	if (a < 0)
-	    a = -a;
-	dist += a;
-	a = n[2] - r;
-	if (a < 0)
-	    a = -a;
-	dist += a;
-	if (dist < bestd) {
-	    bestd = dist;
-	    bestpos = i;
-	}
-	biasdist = dist - ((*p) >> (intbiasshift - netbiasshift));
-	if (biasdist < bestbiasd) {
-	    bestbiasd = biasdist;
-	    bestbiaspos = i;
-	}
-	betafreq = (*f >> betashift);
-	*f++ -= betafreq;
-	*p++ += (betafreq << gammashift);
-    }
-    freq[bestpos] += beta;
-    bias[bestpos] -= betagamma;
-    return (bestbiaspos);
-}
-
-
-/* Move neuron i towards biased (b,g,r) by factor alpha
-   ---------------------------------------------------- */
-
-static void            altersingle(alpha, i, b, g, r)
- int    alpha, i, b, g, r;
-{
-     int   *n;
-
-    n = network[i];		/* alter hit neuron */
-    *n -= (alpha * (*n - b)) / initalpha;
-    n++;
-    *n -= (alpha * (*n - g)) / initalpha;
-    n++;
-    *n -= (alpha * (*n - r)) / initalpha;
-}
-
-
-/* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2))
-   in radpower[|i-j|]
-   --------------------------------------------------------------
-   ------------------- */
-
-static void            alterneigh(rad, i, b, g, r)
-int             rad, i;
- int    b, g, r;
-{
-     int    j, k, lo, hi, a;
-     int   *p, *q;
-
-    lo = i - rad;
-    if (lo < -1)
-	lo = -1;
-    hi = i + rad;
-    if (hi > netsize)
-	hi = netsize;
-
-    j = i + 1;
-    k = i - 1;
-    q = radpower;
-    while ((j < hi) || (k > lo)) {
-	a = (*(++q));
-	if (j < hi) {
-	    p = network[j];
-	    *p -= (a * (*p - b)) / alpharadbias;
-	    p++;
-	    *p -= (a * (*p - g)) / alpharadbias;
-	    p++;
-	    *p -= (a * (*p - r)) / alpharadbias;
-	    j++;
-	}
-	if (k > lo) {
-	    p = network[k];
-	    *p -= (a * (*p - b)) / alpharadbias;
-	    p++;
-	    *p -= (a * (*p - g)) / alpharadbias;
-	    p++;
-	    *p -= (a * (*p - r)) / alpharadbias;
-	    k--;
-	}
-    }
-}
-
-
-/* Main Learning Loop
-   ------------------ */
-//static void            learn()
-void            learn()
-{
-    int    i, j, b, g, r;
-    int    radius, rad, alpha, step, delta, samplepixels;
-    unsigned char *p;
-    unsigned char  *lim;
-
-    alphadec = 30 + ((samplefac - 1) / 3);
-    p = thepicture;
-    lim = thepicture + lengthcount;
-    samplepixels = lengthcount / (3 * samplefac);
-    delta = samplepixels / ncycles;
-    alpha = initalpha;
-    radius = initradius;
-
-    rad = radius >> radiusbiasshift;
-    if (rad <= 1)
-	rad = 0;
-    for (i = 0; i < rad; i++)
-	radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
-
-//      printf("beginning 1D learning: initial radius=%d\n", rad);
-
-    if ((lengthcount % prime1) != 0)
-	step = 3 * prime1;
-    else {
-	if ((lengthcount % prime2) != 0)
-	    step = 3 * prime2;
-	else {
-	    if ((lengthcount % prime3) != 0)
-		step = 3 * prime3;
-	    else
-		step = 3 * prime4;
-	}
-    }
-
-    i = 0;
-    while (i < samplepixels) {
-	b = p[0] << netbiasshift;
-	g = p[1] << netbiasshift;
-	r = p[2] << netbiasshift;
-	j = contest(b, g, r);
-
-	altersingle(alpha, j, b, g, r);
-	if (rad)
-	    alterneigh(rad, j, b, g, r);	/* alter neighbours */
-
-	p += step;
-	if (p >= lim)
-	    p -= lengthcount;
-
-	i++;
-	if (i % delta == 0) {
-	    alpha -= alpha / alphadec;
-	    radius -= radius / radiusdec;
-	    rad = radius >> radiusbiasshift;
-	    if (rad <= 1)
-		rad = 0;
-	    for (j = 0; j < rad; j++)
-		radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
-	}
-    }
-//      printf("finished 1D learning: final alpha=%f !\n",((float)alpha)/initalpha);
-}
-
-
-
-static void            writemap(unsigned char *f)
-{
-    int             j, k = 0;
-
-	//// BGR
-	//for (j = 0; j < /*netsize*/ colorsreq; j++) {
-	//    f[k] = network[j][2];
-	//    k++;
-	//    f[k] = network[j][1];
-	//    k++;
-	//    f[k] = network[j][0];
-	//    k++;
-	//}
-	//--changed.(soezimaster)
-	//RGB
-    //for (j = 0; j < /*netsize*/ colorsreq; j++) {
-	for (j = 0; j <netsize; j++) {
-		f[k++] = network[j][0];
-		f[k++] = network[j][1];
-		f[k++] = network[j][2];
-	}
-}
-
-
-
-static void Quantize24Bit(unsigned char *pic_in,
-	unsigned char *pic_out, unsigned char *pal_out,
-	int length, int reduce_to, int sample_factor)
-{
-    int             i;
-
-    netsize = reduce_to;
-    initnet(pic_in, length, sample_factor);
-
-    learn();
-    unbiasnet();
-
-    writemap(pal_out);
-    inxbuild();
-
-	for (i = 0; i < length; i += 3)
-		pic_out[i / 3] = inxsearch(pic_in[i+0], pic_in[i+1], pic_in[i+2]);
-}
-
-//int neuReduce(unsigned char *RGBpic, int numcolors, long picsize, int sfactor)
-int neuReduce(unsigned char *RGBpic, int numcolors, long picsize, int sfactor,
-						unsigned char *QuantizedPicture, unsigned char *QuantizedPalette)
-{
-    colorsreq = numcolors;
-    Quantize24Bit(RGBpic,
-		QuantizedPicture,
-		QuantizedPalette,
-		picsize*3L,
-		numcolors,
-		sfactor);
-    return 0;
-}
-
-/* Program Skeleton
-   ----------------
-   [select samplefac in range 1..30]
-   [read image from input file]
-   pic_in = (unsigned char*) malloc(3*width*height);
-   initnet(pic_in,3*width*height,samplefac);
-   learn();
-   unbiasnet();
-   [write output image header, using writecolourmap(f)]
-   inxbuild();
-   write output image using inxsearch(b,g,r)
- */
-/* Output:
-        QuantizedPicture[picsize];
-        QuantizedPalette[numcolors*3];
-*/