Struct color_quant::NeuQuant

pub struct NeuQuant {
    pub(crate) network: Vec<Quad<f64>>,
    pub(crate) colormap: Vec<Quad<i32>>,
    pub(crate) netindex: Vec<usize>,
    pub(crate) bias: Vec<f64>,
    pub(crate) freq: Vec<f64>,
    pub(crate) samplefac: i32,
    pub(crate) netsize: usize,
}

Fields

network: Vec<Quad<f64>>

colormap: Vec<Quad<i32>>

netindex: Vec<usize>

bias: Vec<f64>

freq: Vec<f64>

samplefac: i32

netsize: usize

Implementations

impl NeuQuant

pub fn new(samplefac: i32, colors: usize, pixels: &[u8]) -> Self

Creates a new neuronal network and trains it with the supplied data.

Pixels are assumed to be in RGBA format. colors should be $>=64$. samplefac determines the faction of the sample that will be used to train the network. Its value must be in the range $[1, 30]$. A value of $1$ thus produces the best result but is also slowest. $10$ is a good compromise between speed and quality.

pub fn init(&mut self, pixels: &[u8])

Initializes the neuronal network and trains it with the supplied data.

This method gets called by Self::new.

pub fn map_pixel(&self, pixel: &mut [u8])

Maps the rgba-pixel in-place to the best-matching color in the color map.

pub fn index_of(&self, pixel: &[u8]) -> usize

Finds the best-matching index in the color map.

pixel is assumed to be in RGBA format.

pub fn lookup(&self, idx: usize) -> Option<[u8; 4]>

Lookup pixel values for color at idx in the colormap.

pub fn color_map_rgba(&self) -> Vec<u8>

Returns the RGBA color map calculated from the sample.

pub fn color_map_rgb(&self) -> Vec<u8>

Returns the RGBA color map calculated from the sample.

pub(crate) fn salter_single(&mut self, alpha: f64, i: i32, quad: Quad<f64>)

Move neuron i towards biased (a,b,g,r) by factor alpha

pub(crate) fn alter_neighbour( &mut self, alpha: f64, rad: i32, i: i32, quad: Quad<f64> )

Move neuron adjacent neurons towards biased (a,b,g,r) by factor alpha

pub(crate) fn contest(&mut self, b: f64, g: f64, r: f64, a: f64) -> i32

Search for biased BGR values 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/self.netsize)-freq[i])

pub(crate) fn learn(&mut self, pixels: &[u8])

Main learning loop Note: the number of learning cycles is crucial and the parameters are not optimized for net sizes < 26 or > 256. 1064 colors seems to work fine

pub(crate) fn build_colormap(&mut self)

initializes the color map

pub(crate) fn build_netindex(&mut self)

Insertion sort of network and building of netindex[0..255]

pub(crate) fn search_netindex(&self, b: u8, g: u8, r: u8, a: u8) -> usize

Search for best matching color