Color quantization: Difference between revisions

# 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|Common Lisp}}==

{{libheader|opticl}}

Use median cut.

(:use #:cl

#:opticl))

(quantized (gethash original color-map)))

(values-list quantized)))

 

=={{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;

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}}==

A very basic median cut algorithm, no dithering.

 

import (

*pq = q[:n]

return c

 

=={{header|Haskell}}==

{{libheader|JuicyPixels}}

A variation of the median cut algorithm by splitting color space on the nearest to the mean instead. It provides lower error than the Gimp output sample.

import qualified Data.Foldable as Fold

import qualified Data.List as List

case args of

[path, outpath] -> quantizeIO path outpath 16

 

=={{header|J}}==

Here, we use a simplistic averaging technique to build an initial set of colors and then use k-means clustering to refine them.

 

C=. /:~ 256 #.inv ,y NB. colors

G=. x (i.@] <.@* %) #C NB. groups (initial)

G=. (i. <./)"1 C +/&.:*: .- |:Q

end.Q

 

The left argument is the number of colors desired.

The result is the colors represented as pixel triples (blue, green, red). They are shown here as fractional numbers, but they should be either rounded to the nearest integer in the range 0..255 (and possibly converted back to bmp integer form) or scaled so they are floating point triples in the range 0..1.

 

7.52532 22.3347 0.650468

8.20129 54.4678 0.0326828

164.969 199.742 67.0467

179.849 207.594 109.973

 

=={{header|Julia}}==

The Images package for Julia uses the ImageMagick libraries by default, but this Julia module does not currently implement ImageMagick's support for color quantization. However, once ImageMagick is installed for the Images Julia module, a direct call to ImageMagick's convert command is possible.

const execstring =`convert Quantum_frog.png -dither None -colors 16 Quantum_frog_new.png`

run(execstring)

 

=={{header|Kotlin}}==

{{works with|Ubuntu 16.04}}

Rather than coding this from scratch, we invoke programatically ImageMagick's 'convert' tool which has all this stuff built in.

 

import java.io.BufferedReader

}

br.close()

 

{{output}}

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{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|Perl}}==

use warnings;

 

$img->read(file => 'frog.png');

my $img16 = $img->to_paletted({ max_colors => 16});

Compare offsite images: [https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/frog.png frog.png] vs.

[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/frog-16.png frog-16.png]

 

=={{header|Phix}}==

{{trans|Tcl}}

Gui app, shows original and modified side-by-side.

include pGUI.e

 

imImage new_image = imImageCreateBased(im1, -1, -1, IM_RGB, -1)

imConvertColorSpace(im1, new_image)

im1 = new_image

end if

Ihandle dlg = IupDialog(IupHbox({label1, label2}))

IupSetAttribute(dlg, "TITLE", "Color quantization")

IupShow(dlg)

 

IupMainLoop()

 

=={{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|Python}}==

 

if __name__=="__main__":

im = Image.open("frog.png")

im2 = im.quantize(16)

 

=={{header|Racket}}==

#lang racket/base

(require racket/class

r g b))

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

 

=={{header|Raku}}==

{{works with|Rakudo|2018.10}}

 

use MagickWand::Enums;

 

$frog.read("./Quantum_frog.png");

$frog.quantize(16, RGBColorspace, 0, True, False);

See: [https://github.com/thundergnat/rc/blob/master/img/Quantum-frog-16-perl6.png Quantum-frog-16-perl6.png] (offsite .png image)

 

=={{header|Sidef}}==

 

func quantize_image(n = 16, input, output='output.png') {

}

 

 

=={{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|AWK}}