/*

**

** Copyright (C) 1989, 1991 by Jef Poskanzer.

** Copyright (C) 1997, 2000, 2002 by Greg Roelofs; based on an idea by

** Stefan Schneider.

** (C) 2011 by Kornel Lesinski.

**

** Permission to use, copy, modify, and distribute this software and its

** documentation for any purpose and without fee is hereby granted, provided

** that the above copyright notice appear in all copies and that both that

** copyright notice and this permission notice appear in supporting

** documentation. This software is provided "as is" without express or

** implied warranty.

*/

#include <stdlib.h>

#include <stddef.h>

#include "pam.h"

#include "mediancut.h"

#define index_of_channel(ch) (offsetof(f_pixel,ch)/sizeof(float))

static f_pixel averagepixels(unsigned int clrs, const hist_item *achv, float min_opaque_val);

struct box {

};

inline static double variance_diff(double val, const double good_enough) ALWAYS_INLINE;

inline static double variance_diff(double val, const double good_enough)

{

val *= val;

if (val < good_enough*good_enough) return val*0.5;

return val;

}

/** Weighted per-channel variance of the box. It's used to decide which channel to split by */

static f_pixel box_variance(const hist_item achv[], const struct box *box)

{

const f_pixel mean = box->color;

register double variancea=0, variancer=0, varianceg=0, varianceb=0;

f_pixel px_ret;

unsigned int i;

for(i = 0; i < box->colors; ++i) {

f_pixel px = achv[box->ind + i].acolor;

const double weight = achv[box->ind + i].adjusted_weight;

variancea += variance_diff(mean.a - px.a, 2.0/256.0)*weight;

variancer += variance_diff(mean.r - px.r, 1.0/256.0)*weight;

varianceg += variance_diff(mean.g - px.g, 1.0/256.0)*weight;

varianceb += variance_diff(mean.b - px.b, 1.0/256.0)*weight;

}

px_ret.a = variancea*(4.0/16.0);

px_ret.r = variancer*(7.0/16.0);

px_ret.g = varianceg*(9.0/16.0);

px_ret.b = varianceb*(5.0/16.0);

return px_ret;

}

static double box_max_error(const hist_item achv[], const struct box *box)

{

f_pixel mean = box->color;

double max_error = 0;

unsigned int i;

for(i = 0; i < box->colors; ++i) {

const double diff = colordifference(mean, achv[box->ind + i].acolor);

if (diff > max_error) {

max_error = diff;

}

}

return max_error;

}

inline static double color_weight(f_pixel median, hist_item h) ALWAYS_INLINE;

static inline void hist_item_swap(hist_item *l, hist_item *r)

{

if (l != r) {

hist_item t = *l;

*l = *r;

*r = t;

}

}

inline static unsigned int qsort_pivot(const hist_item *const base, const unsigned int len) ALWAYS_INLINE;

inline static unsigned int qsort_pivot(const hist_item *const base, const unsigned int len)

{

if (len < 32) {

return len/2;

} else {

const unsigned int aidx=8, bidx=len/2, cidx=len-1;

const unsigned int a=base[aidx].sort_value, b=base[bidx].sort_value, c=base[cidx].sort_value;

return (a < b) ? ((b < c) ? bidx : ((a < c) ? cidx : aidx ))

: ((b > c) ? bidx : ((a < c) ? aidx : cidx ));

}

}

inline static unsigned int qsort_partition(hist_item *const base, const unsigned int len) ALWAYS_INLINE;

inline static unsigned int qsort_partition(hist_item *const base, const unsigned int len)

{

unsigned int l = 1, r = len;

register unsigned int pivot_value;

if (len >= 8) {

hist_item_swap(&base[0], &base[qsort_pivot(base,len)]);

}

pivot_value = base[0].sort_value;

while (l < r) {

if (base[l].sort_value >= pivot_value) {

l++;

} else {

while(l < --r && base[r].sort_value <= pivot_value) {}

hist_item_swap(&base[l], &base[r]);

}

}

l--;

hist_item_swap(&base[0], &base[l]);

return l;

}

/** this is a simple qsort that completely sorts only elements between sort_start and +sort_len. Used to find median of the set. */

static void hist_item_sort_range(hist_item *base, unsigned int len, int sort_start, const int sort_len)

{

do {

const unsigned int l = qsort_partition(base, len), r = l+1;

if (sort_start+sort_len > 0 && (signed)l >= sort_start && l > 0) {

hist_item_sort_range(base, l, sort_start, sort_len);

}

if (len > r && r < sort_start+sort_len && (signed)len > sort_start) {

base += r; len -= r; sort_start -= r; // tail-recursive "call"

} else return;

} while(1);

}

/** sorts array to make sum of weights lower than halfvar one side, returns edge between <halfvar and >halfvar parts of the set */

static hist_item *hist_item_sort_halfvar(hist_item *base, unsigned int len, double *const lowervar, const double halfvar)

{

do {

const unsigned int l = qsort_partition(base, len), r = l+1;

// check if sum of left side is smaller than half,

// if it is, then it doesn't need to be sorted

unsigned int t = 0; double tmpsum = *lowervar;

while (t <= l && tmpsum < halfvar) tmpsum += base[t++].color_weight;

if (tmpsum < halfvar) {

*lowervar = tmpsum;

} else {

if (l > 0) {

hist_item *res = hist_item_sort_halfvar(base, l, lowervar, halfvar);

if (res) return res;

} else {

// End of left recursion. This will be executed in order from the first element.

*lowervar += base[0].color_weight;

if (*lowervar > halfvar) return &base[0];

}

}

if (len > r) {

base += r; len -= r; // tail-recursive "call"

} else {

*lowervar += base[r].color_weight;

return (*lowervar > halfvar) ? &base[r] : NULL;

}

} while(1);

}

static f_pixel get_median(const struct box *b, hist_item achv[]);

typedef struct {

unsigned int chan; float variance;

} channelvariance;

static int comparevariance(const void *ch1, const void *ch2)

{

return ((const channelvariance*)ch1)->variance > ((const channelvariance*)ch2)->variance ? -1 :

(((const channelvariance*)ch1)->variance < ((const channelvariance*)ch2)->variance ? 1 : 0);

}

/** Finds which channels need to be sorted first and preproceses achv for fast sort */

static double prepare_sort(struct box *b, hist_item achv[])

{

unsigned int i, j;

double totalvar = 0;

unsigned int ind, end;

register f_pixel median;

/*

** Sort dimensions by their variance, and then sort colors first by dimension with highest variance

*/

channelvariance channels[4] = {

{index_of_channel(r), b->variance.r},

{index_of_channel(g), b->variance.g},

{index_of_channel(b), b->variance.b},

{index_of_channel(a), b->variance.a},

};

qsort(channels, 4, sizeof(channels[0]), comparevariance);

for(i=0; i < b->colors; i++) {

const float *chans = (const float *)&achv[b->ind + i].acolor;

// Only the first channel really matters. When trying median cut many times

// with different histogram weights, I don't want sort randomness to influence outcome.

achv[b->ind + i].sort_value = ((unsigned int)(chans[channels[0].chan]*65535.0)<<16) |

(unsigned int)((chans[channels[2].chan] + chans[channels[1].chan]/2.0 + chans[channels[3].chan]/4.0)*65535.0);

}

median = get_median(b, achv);

// box will be split to make color_weight of each side even

ind = b->ind; end = ind+b->colors;

for(j=ind; j < end; j++) totalvar += (achv[j].color_weight = color_weight(median, achv[j]));

return totalvar / 2.0;

}

/** finds median in unsorted set by sorting only minimum required */

static f_pixel get_median(const struct box *b, hist_item achv[])

{

const unsigned int median_start = (b->colors-1)/2;

hist_item_sort_range(&(achv[b->ind]), b->colors,

median_start,

b->colors&1 ? 1 : 2);

if (b->colors&1) return achv[b->ind + median_start].acolor;

return averagepixels(2, &achv[b->ind + median_start], 1.0);

}

/*

** Find the best splittable box. -1 if no boxes are splittable.

*/

static int best_splittable_box(struct box* bv, unsigned int boxes, const double max_mse)

{

int bi=-1; double maxsum=0;

unsigned int i;

for(i=0; i < boxes; i++) {

// looks only at max variance, because it's only going to split by it

const double cv = MAX(bv[i].variance.r, MAX(bv[i].variance.g,bv[i].variance.b));

double thissum = bv[i].sum * MAX(bv[i].variance.a, cv);

if (bv[i].colors < 2) continue;

if (bv[i].max_error > max_mse) {

thissum = thissum* bv[i].max_error/max_mse;

}

if (thissum > maxsum) {

maxsum = thissum;

bi = i;

}

}

return bi;

}

inline static double color_weight(f_pixel median, hist_item h)

{

float diff = colordifference(median, h.acolor);

// if color is "good enough", don't split further

if (diff < 2.f/256.f/256.f) diff /= 2.f;

return sqrt(diff) * (sqrt(1.0+h.adjusted_weight)-1.0);

}

static colormap *colormap_from_boxes(struct box* bv, unsigned int boxes, hist_item *achv);

static void adjust_histogram(hist_item *achv, const colormap *map, const struct box* bv, unsigned int boxes);

double box_error(const struct box *box, const hist_item achv[])

{

f_pixel avg = box->color;

unsigned int i;

double total_error=0;

for (i = 0; i < box->colors; ++i) {

total_error += colordifference(avg, achv[box->ind + i].acolor) * achv[box->ind + i].perceptual_weight;

}

return total_error;

}

static bool total_box_error_below_target(double target_mse, struct box bv[], unsigned int boxes, const histogram *hist)

{

double total_error=0;

unsigned int i;

target_mse *= hist->total_perceptual_weight;

for(i=0; i < boxes; i++) {

// error is (re)calculated lazily

if (bv[i].total_error >= 0) {

total_error += bv[i].total_error;

}

if (total_error > target_mse) return false;

}

for(i=0; i < boxes; i++) {

if (bv[i].total_error < 0) {

bv[i].total_error = box_error(&bv[i], hist->achv);

total_error += bv[i].total_error;

}

if (total_error > target_mse) return false;

}

return true;

}

/*

** Here is the fun part, the median-cut colormap generator. This is based

** on Paul Heckbert's paper, "Color Image Quantization for Frame Buffer

** Display," SIGGRAPH 1982 Proceedings, page 297.

*/

colormap *mediancut(histogram *hist, const float min_opaque_val, const unsigned int newcolors, const double target_mse, const double max_mse)

{

hist_item *achv = hist->achv;

struct box bv[newcolors];

unsigned int i;

unsigned int boxes = 1;

/*

** Set up the initial box.

*/

bv[0].ind = 0;

bv[0].colors = hist->size;

bv[0].color = averagepixels(bv[0].colors, &achv[bv[0].ind], min_opaque_val);

bv[0].variance = box_variance(achv, &bv[0]);

bv[0].max_error = box_max_error(achv, &bv[0]);

bv[0].sum = 0;

bv[0].total_error = -1;

for(i=0; i < bv[0].colors; i++) bv[0].sum += achv[i].adjusted_weight;

// remember smaller palette for fast searching

colormap *representative_subset = NULL;

unsigned int subset_size = ceilf(powf(newcolors,0.7f));

/*

** Main loop: split boxes until we have enough.

*/

while (boxes < newcolors) {

if (boxes == subset_size) {

representative_subset = colormap_from_boxes(bv, boxes, achv);

}

// first splits boxes that exceed quality limit (to have colors for things like odd green pixel),

// later raises the limit to allow large smooth areas/gradients get colors.

const double current_max_mse = max_mse + (boxes/(double)newcolors)*16.0*max_mse;

const int bi = best_splittable_box(bv, boxes, current_max_mse);

if (bi < 0)

break; /* ran out of colors! */

unsigned int indx = bv[bi].ind;

unsigned int clrs = bv[bi].colors;

/*

Classic implementation tries to get even number of colors or pixels in each subdivision.

Here, instead of popularity I use (sqrt(popularity)*variance) metric.

Each subdivision balances number of pixels (popular colors) and low variance -

boxes can be large if they have similar colors. Later boxes with high variance

will be more likely to be split.

Median used as expected value gives much better results than mean.

*/

const double halfvar = prepare_sort(&bv[bi], achv);

double lowervar=0;

// hist_item_sort_halfvar sorts and sums lowervar at the same time

// returns item to break at …minus one, which does smell like an off-by-one error.

hist_item *break_p = hist_item_sort_halfvar(&achv[indx], clrs, &lowervar, halfvar);

unsigned int break_at = MIN(clrs-1, break_p - &achv[indx] + 1);

/*

** Split the box.

*/

double sm = bv[bi].sum;

double lowersum = 0;

unsigned int i;

for(i=0; i < break_at; i++) lowersum += achv[indx + i].adjusted_weight;

bv[bi].colors = break_at;

bv[bi].sum = lowersum;

bv[bi].color = averagepixels(bv[bi].colors, &achv[bv[bi].ind], min_opaque_val);

bv[bi].total_error = -1;

bv[bi].variance = box_variance(achv, &bv[bi]);

bv[bi].max_error = box_max_error(achv, &bv[bi]);

bv[boxes].ind = indx + break_at;

bv[boxes].colors = clrs - break_at;

bv[boxes].sum = sm - lowersum;

bv[boxes].color = averagepixels(bv[boxes].colors, &achv[bv[boxes].ind], min_opaque_val);

bv[boxes].total_error = -1;

bv[boxes].variance = box_variance(achv, &bv[boxes]);

bv[boxes].max_error = box_max_error(achv, &bv[boxes]);

++boxes;

if (total_box_error_below_target(target_mse, bv, boxes, hist)) {

break;

}

}

colormap *map = colormap_from_boxes(bv, boxes, achv);

map->subset_palette = representative_subset;

adjust_histogram(achv, map, bv, boxes);

return map;

}

static colormap *colormap_from_boxes(struct box* bv, unsigned int boxes, hist_item *achv)

{

/*

** Ok, we've got enough boxes. Now choose a representative color for

** each box. There are a number of possible ways to make this choice.

** One would be to choose the center of the box; this ignores any structure

** within the boxes. Another method would be to average all the colors in

** the box - this is the method specified in Heckbert's paper.

*/

colormap *map = pam_colormap(boxes);

unsigned int bi;

for(bi = 0; bi < boxes; ++bi) {

unsigned int i;

map->palette[bi].acolor = bv[bi].color;

/* store total color popularity (perceptual_weight is approximation of it) */

map->palette[bi].popularity = 0;

for(i=bv[bi].ind; i < bv[bi].ind+bv[bi].colors; i++) {

map->palette[bi].popularity += achv[i].perceptual_weight;

}

}

return map;

}

/* increase histogram popularity by difference from the final color (this is used as part of feedback loop) */

static void adjust_histogram(hist_item *achv, const colormap *map, const struct box* bv, unsigned int boxes)

{

unsigned int bi;

for(bi = 0; bi < boxes; ++bi) {

unsigned int i;

for(i=bv[bi].ind; i < bv[bi].ind+bv[bi].colors; i++) {

achv[i].adjusted_weight *= sqrt(1.0 +colordifference(map->palette[bi].acolor, achv[i].acolor)/4.0);

}

}

}

static f_pixel averagepixels(unsigned int clrs, const hist_item *achv, const float min_opaque_val)

{

double r = 0, g = 0, b = 0, a = 0, sum = 0;

float maxa = 0;

unsigned int i;

for(i = 0; i < clrs; ++i) {

const f_pixel px = achv[i].acolor;

double tmp, weight = 1.0f;

/* give more weight to colors that are further away from average

this is intended to prevent desaturation of images and fading of whites

*/

tmp = (0.5f - px.r);

weight += tmp*tmp;

tmp = (0.5f - px.g);

weight += tmp*tmp;

tmp = (0.5f - px.b);

weight += tmp*tmp;

weight *= achv[i].adjusted_weight;

sum += weight;

r += px.r * weight;

g += px.g * weight;

b += px.b * weight;

a += px.a * weight;

/* find if there are opaque colors, in case we're supposed to preserve opacity exactly (ie_bug) */

if (px.a > maxa) maxa = px.a;

}

/* Colors are in premultiplied alpha colorspace, so they'll blend OK

even if different opacities were mixed together */

if (!sum) sum=1;

a /= sum;

r /= sum;

g /= sum;

b /= sum;

assert(!isnan(r) && !isnan(g) && !isnan(b) && !isnan(a));

/** if there was at least one completely opaque color, "round" final color to opaque */

if (a >= min_opaque_val && maxa >= (255.0/256.0)) a = 1;

return (f_pixel){.r=r, .g=g, .b=b, .a=a};

}