Color quantization: Difference between revisions

Note: the funny color bar on top of the frog image is intentional.

<br clear=left>

=={{header|C}}==

[[file:quantum_frog_C.png|C output|thumb|200px]]

# Node folding priorities are tracked by a binary heap instead of typical linked list.

The output image is better at preserving textures of the original than Gimp, though it obviously depends on the input image. This particular frog image has the color bar added at the top specifically to throw off some early truncation algorithms, which Gimp is suseptible to.

struct oct_node_t{

/* sum of all colors represented by this node. 64 bit in case of HUGE image */

node_free();

free(heap.buf);

 

=={{header|D}}==

{{trans|OCaml}}

This code retains the style of the original OCaML code, and uses the bitmap module from the Bitmap Task.

std.math, std.range, std.conv, std.string, bitmap;

 

const imq = colorQuantize(im, nCols);

imq.savePPM6("quantum_frog_quantized.ppm");

 

===Imperative Version===

{{trans|C}}

This code retains part of the style of the original C code.

import std.stdio: stderr, File;

import std.ascii: isWhite;

import std.exception: enforce;

import std.array: empty;

 

enum ON_INHEAP = 1;

} while (line.length && line[0] == '#');

 

auto img = imageNew(size[0], size[1]);

enforce(fIn.readln.strip == "255");

}

 

uint alloc, n;

OctreeNode** buf;

}

 

in {

assert(a != null);

assert(b != null);

} out(result) {

} body {

if (a.nKids < b.nKids)

}

 

in {

assert(h != null);

if (m >= h.n)

break;

m++;

 

break;

 

}

 

in {

assert(h != null);

while (n > 1) {

auto prev = h.buf[n / 2];

break;

 

}

 

in {

assert(h != null);

}

 

in {

assert(h != null);

}

 

out(result) {

assert(result != null);

}

 

out {

} body {

 

}

 

}

 

nothrow @nogc

in {

assert(root != null);

assert(pix != null);

} out(result) {

assert(result != null);

!!(pix[2] & bit);

if (!root.kids[i])

 

root = root.kids[i];

}

 

in {

assert(p != null);

}

 

in {

assert(im != null);

assert(npx != null);

auto pix = im.pix.ptr;

 

for (auto px = npx, i = 0u; i < im.h; i++) {

for (uint j = 0; j < im.w; j++, pix += 3, px += 3) {

}

}

for (auto px = npx, i = 0u; i < im.h; i++) {

for (uint j = 0; j < im.w; j++, pix += 3, px += 3) {

 

const nd = nearestColor(px);

v[0] = cast(uint)(px[0] - nd.r);

v[1] = cast(uint)(px[1] - nd.g);

 

if (j < im.w - 1) {

}

 

continue;

 

 

if (j < im.w - 1) {

}

 

if (j) {

}

}

} body {

auto pix = im.pix.ptr;

OctreeNode[] pool;

 

for (uint i = 0; i < im.w * im.h; i++, pix += 3)

 

while (heap.n > nColors + 1)

 

foreach (immutable i; 1 .. heap.n) {

}

 

heap.buf.free;

}

im.free;

return 0;

Compiled with ldc2, it runs on the quantum_frog image in about 0.20 seconds with dithering and about 0.10 seconds without dithering.

 

=={{header|Go}}==

 

import (

}

img, err := png.Decode(f)

log.Fatal(err)

}

if err != nil {

log.Fatal(err)

}

log.Fatal(err)

}

*pq = q[:n]

return c

 

 

=={{header|OCaml}}==

Here we use a simplified method inspired from this paper: [http://www.leptonica.com/papers/mediancut.pdf www.leptonica.com/papers/mediancut.pdf]

 

List.filter ((<>) rem) from

 

done;

done;

 

 

 

 

 

 

 

 

=={{header|PureBasic}}==

[[file:Compare_16_Quantum_frog_PureBasic.png|comparison|thumb|200px]]

[[file:Compare_16_Quantum_frog_histograms_PureBasic.png|histogram (external application)|thumb|200px]]

; ColorQuantization.pb

 

 

 

 

=={{header|Racket}}==

#lang racket/base

(require racket/class

r g b))

(loop child (add1 level))))))

 

 

=={{header|Tcl}}==

{{trans|OCaml}}

{{libheader|Tk}}

package require Tk

 

}

return $newimg

Demonstration code:

set dst [colorQuant $src 16]

# Save as GIF now that quantization is done, then exit explicitly (no GUI desired)

$dst write quantum_frog_compressed.gif

 

{{omit from|GUISS}}