mirror of
https://github.com/dankamongmen/notcurses
synced 2025-03-08 15:49:03 -05:00
kohonen neural net experiment
This commit is contained in:
nick black
parent
b58b091e81
commit
a85a18dd3a
344
src/lib/kohonen.c
Normal file
344
src/lib/kohonen.c
Normal file
@ -0,0 +1,344 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "neuquant.h"
|
||||
|
||||
// kohonen neural net adapted from dekker's "kohonen neural networks for
|
||||
// optimal colour quantization" (2009)
|
||||
|
||||
#define netsize 256
|
||||
#define maxnetpos (netsize-1)
|
||||
#define netbiasshift 4 /* bias for color 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 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)
|
||||
|
||||
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 */
|
||||
|
||||
kohonenctx* initnet(const void *data, int leny, int linesize, int lenx, int sample){
|
||||
kohonenctx* ret = malloc(sizeof(*ret));
|
||||
if(ret){
|
||||
int i;
|
||||
int *p;
|
||||
|
||||
for (i=0; i<netsize; i++) {
|
||||
p = ret->network[i];
|
||||
p[0] = p[1] = p[2] = (i << (netbiasshift+8))/netsize;
|
||||
p[3] = 0;
|
||||
freq[i] = intbias/netsize; /* 1/netsize */
|
||||
bias[i] = 0;
|
||||
}
|
||||
ret->data = data;
|
||||
ret->linesize = linesize;
|
||||
ret->samplefac = sample;
|
||||
ret->leny = leny;
|
||||
ret->lenx = lenx;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* Unbias network to give byte values 0..255 and record position i to prepare for sort
|
||||
----------------------------------------------------------------------------------- */
|
||||
|
||||
void unbiasnet(kohonenctx* kctx){
|
||||
int i,j,temp;
|
||||
|
||||
for (i=0; i<netsize; i++) {
|
||||
for (j=0; j<3; j++) {
|
||||
temp = (kctx->network[i][j] + (1 << (netbiasshift - 1))) >> netbiasshift;
|
||||
if (temp > 255) temp = 255;
|
||||
kctx->network[i][j] = temp;
|
||||
}
|
||||
kctx->network[i][3] = i; /* record color no */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void netcolor(const kohonenctx* kctx, int color, unsigned char rgb[static 3]){
|
||||
rgb[0] = kctx->network[color][0];
|
||||
rgb[1] = kctx->network[color][1];
|
||||
rgb[2] = kctx->network[color][2];
|
||||
}
|
||||
|
||||
void inxbuild(kohonenctx* kctx){
|
||||
int i,j,smallpos,smallval;
|
||||
int *p,*q;
|
||||
int previouscol,startpos;
|
||||
|
||||
previouscol = 0;
|
||||
startpos = 0;
|
||||
for (i=0; i<netsize; i++) {
|
||||
p = kctx->network[i];
|
||||
smallpos = i;
|
||||
smallval = p[1]; /* index on g */
|
||||
/* find smallest in i..netsize-1 */
|
||||
for (j=i+1; j<netsize; j++) {
|
||||
q = kctx->network[j];
|
||||
if (q[1] < smallval) { /* index on g */
|
||||
smallpos = j;
|
||||
smallval = q[1]; /* index on g */
|
||||
}
|
||||
}
|
||||
q = kctx->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 */
|
||||
}
|
||||
|
||||
|
||||
int inxsearch(kohonenctx* kctx, int r, int g, int b){
|
||||
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 = kctx->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] - r; if (a<0) a = -a;
|
||||
dist += a;
|
||||
if (dist<bestd) {
|
||||
a = p[2] - b; if (a<0) a = -a;
|
||||
dist += a;
|
||||
if (dist<bestd) {bestd=dist; best=p[3];}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (j>=0) {
|
||||
p = kctx->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] - r; if (a<0) a = -a;
|
||||
dist += a;
|
||||
if (dist<bestd) {
|
||||
a = p[2] - b; if (a<0) a = -a;
|
||||
dist += a;
|
||||
if (dist<bestd) {bestd=dist; best=p[3];}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return(best);
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
contest(kohonenctx* kctx, int r, int g, int b){
|
||||
/* 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 = kctx->network[i];
|
||||
dist = n[0] - r; if (dist<0) dist = -dist;
|
||||
a = n[1] - g; if (a<0) a = -a;
|
||||
dist += a;
|
||||
a = n[2] - b; 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 (r,g,b) by factor alpha
|
||||
---------------------------------------------------- */
|
||||
|
||||
static void
|
||||
altersingle(kohonenctx* kctx, int alpha, int i, int r, int g, int b){
|
||||
int *n;
|
||||
|
||||
n = kctx->network[i]; /* alter hit neuron */
|
||||
*n -= (alpha*(*n - r)) / initalpha;
|
||||
n++;
|
||||
*n -= (alpha*(*n - g)) / initalpha;
|
||||
n++;
|
||||
*n -= (alpha*(*n - b)) / initalpha;
|
||||
}
|
||||
|
||||
|
||||
/* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
|
||||
--------------------------------------------------------------------------------- */
|
||||
|
||||
static void
|
||||
alterneigh(kohonenctx* kctx, int rad, int i, int r, int g, int b){
|
||||
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 = kctx->network[j];
|
||||
*p -= (a*(*p - r)) / alpharadbias;
|
||||
p++;
|
||||
*p -= (a*(*p - g)) / alpharadbias;
|
||||
p++;
|
||||
*p -= (a*(*p - b)) / alpharadbias;
|
||||
j++;
|
||||
}
|
||||
if (k>lo) {
|
||||
p = kctx->network[k];
|
||||
*p -= (a*(*p - r)) / alpharadbias;
|
||||
p++;
|
||||
*p -= (a*(*p - g)) / alpharadbias;
|
||||
p++;
|
||||
*p -= (a*(*p - b)) / alpharadbias;
|
||||
k--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Main Learning Loop
|
||||
------------------ */
|
||||
|
||||
static inline
|
||||
const unsigned char* get_pixel(const kohonenctx* kctx, int pixel){
|
||||
int line = pixel / kctx->lenx;
|
||||
int offx = pixel % kctx->lenx;
|
||||
return kctx->data + kctx->linesize * line + offx * 4;
|
||||
}
|
||||
|
||||
void learn(kohonenctx* kctx){
|
||||
int radius,rad,alpha,step,delta,samplepixels;
|
||||
int i,j;
|
||||
|
||||
alphadec = 30 + ((kctx->samplefac - 1) / 3);
|
||||
int pixel = 0;
|
||||
int lim = kctx->leny * kctx->lenx;
|
||||
samplepixels = lim / (3 * kctx->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));
|
||||
|
||||
if ((lim % prime1) != 0) step = prime1;
|
||||
else {
|
||||
if ((lim % prime2) !=0) step = prime2;
|
||||
else {
|
||||
if ((lim % prime3) !=0) step = prime3;
|
||||
else step = prime4;
|
||||
}
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while (i < samplepixels) {
|
||||
const unsigned char* p = get_pixel(kctx, pixel);
|
||||
int r = p[0] << netbiasshift;
|
||||
int g = p[1] << netbiasshift;
|
||||
int b = p[2] << netbiasshift;
|
||||
fprintf(stderr, "BIAS %4d %4d %4d SRC %3d %3d %3d\n", r, g, b, p[0], p[1], p[2]);
|
||||
j = contest(kctx, r, g, b);
|
||||
|
||||
altersingle(kctx, alpha, j, r, g, b);
|
||||
if(rad){
|
||||
alterneigh(kctx, rad, j, r, g, b); /* alter neighbours */
|
||||
}
|
||||
|
||||
pixel += step;
|
||||
if(pixel >= lim){
|
||||
pixel -= lim;
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void freenet(kohonenctx* kctx){
|
||||
free(kctx);
|
||||
}
|
||||
39
src/lib/neuquant.h
Normal file
39
src/lib/neuquant.h
Normal file
@ -0,0 +1,39 @@
|
||||
#ifndef NOTCURSES_NEUQUANT
|
||||
#define NOTCURSES_NEUQUANT
|
||||
|
||||
typedef struct kohonenctx {
|
||||
const unsigned char* data;
|
||||
int leny, lenx;
|
||||
int linesize;
|
||||
int samplefac; /* sampling factor 1..30 */
|
||||
int network[256][4]; /* the network itself */
|
||||
} kohonenctx;
|
||||
|
||||
/* 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 */
|
||||
|
||||
|
||||
kohonenctx* initnet(const void *data, int leny, int linesize, int lenx, int sample);
|
||||
void freenet(kohonenctx* kctx);
|
||||
|
||||
void unbiasnet(kohonenctx* kctx); /* can edit this function to do output of colour map */
|
||||
|
||||
void netcolor(const kohonenctx* kctx, int color, unsigned char rgb[static 3]);
|
||||
|
||||
void inxbuild(kohonenctx* kctx);
|
||||
|
||||
int inxsearch(kohonenctx* kctx, int r, int g, int b);
|
||||
|
||||
void learn(kohonenctx* kctx);
|
||||
|
||||
#endif
|
||||
155
src/lib/sixel.c
155
src/lib/sixel.c
@ -1,100 +1,16 @@
|
||||
#include "internal.h"
|
||||
|
||||
#define RGBSIZE 3
|
||||
|
||||
static inline void
|
||||
break_sixel_comps(unsigned char comps[static RGBSIZE], uint32_t rgba){
|
||||
comps[0] = ncpixel_r(rgba) * 100 / 255;
|
||||
comps[1] = ncpixel_g(rgba) * 100 / 255;
|
||||
comps[2] = ncpixel_b(rgba) * 100 / 255;
|
||||
//fprintf(stderr, "%u %u %u\n", comps[0], comps[1], comps[2]);
|
||||
}
|
||||
#include "neuquant.h"
|
||||
|
||||
// FIXME you can have more (or fewer) than 256 registers...detect?
|
||||
#define MAXCOLORS 256
|
||||
#define CENTSIZE (4 + (MAXCOLORS > 256))
|
||||
|
||||
// first pass: extract up to 256 sixelspace colors over arbitrarily many sixels
|
||||
// sixelspace is 0..100 corresponding to 0..255, lame =[
|
||||
typedef struct colortable {
|
||||
int colors;
|
||||
int sixelcount;
|
||||
unsigned char table[CENTSIZE * MAXCOLORS]; // components + dtable index
|
||||
} colortable;
|
||||
|
||||
// second pass: construct data for extracted colors over the sixels
|
||||
typedef struct sixeltable {
|
||||
colortable* ctab;
|
||||
unsigned char* data; // |colors|x|sixelcount|-byte arrays
|
||||
kohonenctx* kctx;
|
||||
int sixelcount;
|
||||
} sixeltable;
|
||||
|
||||
static inline int
|
||||
ctable_to_dtable(const unsigned char* ctable){
|
||||
if(MAXCOLORS > 256){
|
||||
return ctable[RGBSIZE] * 256 + ctable[RGBSIZE + 1];
|
||||
}else{
|
||||
return ctable[RGBSIZE];
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
dtable_to_ctable(int dtable, unsigned char* ctable){
|
||||
if(MAXCOLORS > 256){
|
||||
ctable[RGBSIZE] = dtable / 256;
|
||||
ctable[RGBSIZE + 1] = dtable % 256;
|
||||
}else{
|
||||
ctable[RGBSIZE] = dtable;
|
||||
}
|
||||
}
|
||||
|
||||
// returns the index at which the provided color can be found *in the
|
||||
// dtable*, possibly inserting it into the ctable. returns -1 if the
|
||||
// color is not in the table and the table is full.
|
||||
static int
|
||||
find_color(colortable* ctab, unsigned char comps[static RGBSIZE]){
|
||||
int i;
|
||||
if(ctab->colors){
|
||||
int l, r;
|
||||
l = 0;
|
||||
r = ctab->colors - 1;
|
||||
do{
|
||||
i = l + (r - l) / 2;
|
||||
//fprintf(stderr, "%02x%02x%02x L %d R %d m %d\n", comps[0], comps[1], comps[2], l, r, i);
|
||||
int cmp = memcmp(ctab->table + i * CENTSIZE, comps, RGBSIZE);
|
||||
if(cmp == 0){
|
||||
return ctable_to_dtable(ctab->table + i * CENTSIZE);
|
||||
}
|
||||
if(cmp < 0){
|
||||
l = i + 1;
|
||||
}else{ // key is smaller
|
||||
r = i - 1;
|
||||
}
|
||||
//fprintf(stderr, "BCMP: %d L %d R %d m: %d\n", cmp, l, r, i);
|
||||
}while(l <= r);
|
||||
if(r < 0){
|
||||
i = 0;
|
||||
}else if(l == ctab->colors){
|
||||
i = ctab->colors;
|
||||
}else{
|
||||
i = l;
|
||||
}
|
||||
if(ctab->colors == MAXCOLORS){
|
||||
return -1;
|
||||
}
|
||||
if(i < ctab->colors){
|
||||
memmove(ctab->table + (i + 1) * CENTSIZE, ctab->table + i * CENTSIZE,
|
||||
(ctab->colors - i) * CENTSIZE);
|
||||
}
|
||||
}else{
|
||||
i = 0;
|
||||
}
|
||||
memcpy(ctab->table + i * CENTSIZE, comps, RGBSIZE);
|
||||
dtable_to_ctable(ctab->colors, ctab->table + i * CENTSIZE);
|
||||
++ctab->colors;
|
||||
return ctab->colors - 1;
|
||||
//return ctable_to_dtable(ctab->table + i * CENTSIZE);
|
||||
}
|
||||
|
||||
// rather inelegant preprocess of the entire image. colors are converted to the
|
||||
// 100x100x100 sixel colorspace, and built into a table.
|
||||
static int
|
||||
@ -104,19 +20,17 @@ extract_ctable_inner(const uint32_t* data, int linesize, int begy, int begx,
|
||||
for(int visy = begy ; visy < (begy + leny) ; visy += 6){
|
||||
for(int visx = begx ; visx < (begx + lenx) ; visx += 1){
|
||||
for(int sy = visy ; sy < (begy + leny) && sy < visy + 6 ; ++sy){
|
||||
const uint32_t* rgb = (const uint32_t*)(data + (linesize / CENTSIZE * sy) + visx);
|
||||
const uint32_t* rgb = (const uint32_t*)(data + (linesize / 4 * sy) + visx);
|
||||
if(rgba_trans_p(ncpixel_a(*rgb))){
|
||||
continue;
|
||||
}
|
||||
unsigned char comps[RGBSIZE];
|
||||
break_sixel_comps(comps, *rgb);
|
||||
int c = find_color(stab->ctab, comps);
|
||||
int c = inxsearch(stab->kctx, ncpixel_r(*rgb), ncpixel_g(*rgb), ncpixel_b(*rgb));
|
||||
if(c < 0){
|
||||
//fprintf(stderr, "FAILED FINDING COLOR AUGH\n");
|
||||
return -1;
|
||||
}
|
||||
stab->data[c * stab->ctab->sixelcount + pos] |= (1u << (sy - visy));
|
||||
//fprintf(stderr, "color %d pos %d: 0x%x\n", c, pos, stab->data[c * stab->ctab->sixelcount + pos]);
|
||||
stab->data[c * stab->sixelcount + pos] |= (1u << (sy - visy));
|
||||
//fprintf(stderr, "color %d pos %d: 0x%x\n", c, pos, stab->data[c * stab->sixelcount + pos]);
|
||||
}
|
||||
++pos;
|
||||
}
|
||||
@ -126,8 +40,7 @@ extract_ctable_inner(const uint32_t* data, int linesize, int begy, int begx,
|
||||
|
||||
static inline void
|
||||
initialize_stable(sixeltable* stab){
|
||||
stab->ctab->colors = 0;
|
||||
memset(stab->data, 0, stab->ctab->sixelcount * MAXCOLORS);
|
||||
memset(stab->data, 0, stab->sixelcount * MAXCOLORS);
|
||||
}
|
||||
|
||||
// Use as many of the original colors as we can, but not more than will fit
|
||||
@ -182,42 +95,43 @@ write_sixel_data(FILE* fp, int lenx, sixeltable* stab){
|
||||
// unspecified pixels, which we do not want.
|
||||
//fprintf(fp, "\"1;1;%d;%d", lenx, leny);
|
||||
|
||||
for(int i = 0 ; i < stab->ctab->colors ; ++i){
|
||||
const unsigned char* rgb = stab->ctab->table + i * CENTSIZE;
|
||||
fprintf(fp, "#%d;2;%u;%u;%u", i, rgb[0], rgb[1], rgb[2]);
|
||||
for(int i = 0 ; i < MAXCOLORS ; ++i){
|
||||
unsigned char rgb[3];
|
||||
netcolor(stab->kctx, i, rgb);
|
||||
fprintf(stderr, "RGB[%03d]: %3d %3d %3d\n", i, rgb[0], rgb[1], rgb[2]);
|
||||
fprintf(fp, "#%d;2;%u;%u;%u", i, rgb[0] * 100 / 255, rgb[1] * 100 / 255, rgb[2] * 100 / 255);
|
||||
}
|
||||
int p = 0;
|
||||
while(p < stab->ctab->sixelcount){
|
||||
for(int i = 0 ; i < stab->ctab->colors ; ++i){
|
||||
while(p < stab->sixelcount){
|
||||
for(int i = 0 ; i < MAXCOLORS ; ++i){
|
||||
int printed = 0;
|
||||
int seenrle = 0; // number of repetitions
|
||||
unsigned char crle = 0; // character being repeated
|
||||
int idx = ctable_to_dtable(stab->ctab->table + i * CENTSIZE);
|
||||
for(int m = p ; m < stab->ctab->sixelcount && m < p + lenx ; ++m){
|
||||
//fprintf(stderr, "%d ", idx * stab->ctab->sixelcount + m);
|
||||
//fputc(stab->data[idx * stab->ctab->sixelcount + m] + 63, stderr);
|
||||
for(int m = p ; m < stab->sixelcount && m < p + lenx ; ++m){
|
||||
//fprintf(stderr, "%d ", i * stab->sixelcount + m);
|
||||
//fputc(stab->data[i * stab->sixelcount + m] + 63, stderr);
|
||||
if(seenrle){
|
||||
if(stab->data[idx * stab->ctab->sixelcount + m] == crle){
|
||||
if(stab->data[i * stab->sixelcount + m] == crle){
|
||||
++seenrle;
|
||||
}else{
|
||||
write_rle(&printed, i, fp, seenrle, crle);
|
||||
seenrle = 1;
|
||||
crle = stab->data[idx * stab->ctab->sixelcount + m];
|
||||
crle = stab->data[i * stab->sixelcount + m];
|
||||
}
|
||||
}else{
|
||||
seenrle = 1;
|
||||
crle = stab->data[idx * stab->ctab->sixelcount + m];
|
||||
crle = stab->data[i * stab->sixelcount + m];
|
||||
}
|
||||
}
|
||||
if(crle){
|
||||
write_rle(&printed, i, fp, seenrle, crle);
|
||||
}
|
||||
if(i + 1 < stab->ctab->colors){
|
||||
if(i + 1 < MAXCOLORS){
|
||||
if(printed){
|
||||
fputc('$', fp);
|
||||
}
|
||||
}else{
|
||||
if(p + lenx < stab->ctab->sixelcount){
|
||||
if(p + lenx < stab->sixelcount){
|
||||
fputc('-', fp);
|
||||
}
|
||||
}
|
||||
@ -264,26 +178,27 @@ int sixel_blit_inner(ncplane* nc, int placey, int placex, int lenx,
|
||||
int sixel_blit(ncplane* nc, int placey, int placex, int linesize,
|
||||
const void* data, int begy, int begx,
|
||||
int leny, int lenx, unsigned cellpixx){
|
||||
colortable* ctab = malloc(sizeof(*ctab));
|
||||
if(ctab == NULL){
|
||||
return -1;
|
||||
}
|
||||
ctab->sixelcount = (lenx - begx) * ((leny - begy + 5) / 6);
|
||||
int sixelcount = (lenx - begx) * ((leny - begy + 5) / 6);
|
||||
sixeltable stable = {
|
||||
.ctab = ctab,
|
||||
.data = malloc(MAXCOLORS * ctab->sixelcount),
|
||||
.data = malloc(MAXCOLORS * sixelcount),
|
||||
.sixelcount = sixelcount,
|
||||
};
|
||||
if(stable.data == NULL){
|
||||
free(ctab);
|
||||
return -1;
|
||||
}
|
||||
if(extract_color_table(data, linesize, begy, begx, leny, lenx, &stable)){
|
||||
free(ctab);
|
||||
if((stable.kctx = initnet(data, leny, linesize, lenx, 1)) == NULL){
|
||||
free(stable.data);
|
||||
}
|
||||
learn(stable.kctx);
|
||||
unbiasnet(stable.kctx);
|
||||
inxbuild(stable.kctx);
|
||||
if(extract_color_table(data, linesize, begy, begx, leny, lenx, &stable)){
|
||||
free(stable.data);
|
||||
freenet(stable.kctx);
|
||||
return -1;
|
||||
}
|
||||
int r = sixel_blit_inner(nc, placey, placex, lenx, &stable, cellpixx);
|
||||
free(stable.data);
|
||||
free(ctab);
|
||||
freenet(stable.kctx);
|
||||
return r;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user