How can I get modal average colors?

[Tameflame]

My use case is changing the colors of elements on .svg files.

I want to rasterize an .svg file, pick out the most pixel-common colors, and then doing a basic text replacement on the fill attributes of the .svg file.

How can I go about this with this library? Since it's a mean-search function are my options to use a different library or apply some soft of color distance function? I'm thinking the image library might be appropriate but I'll need to figure out the exact pixel count of each color present and I have no idea how I'd go about doing that

Could I have advice on how I might go about either route?

Thanks!

[okaneco]

I'm not too familiar with SVG but that problem does sound like this library might not be the right fit.

If the images are flat or you'll have large areas with a solid color, I'd try using a hashmap for counting the most common colors. After rasterizing, you can populate a hashmap with the color as the key and the count as the value. It could look like the following. Then you can create a Vec of the (keys, values) and sort by the value to find the most common colors.

use std::collections::HashMap;

// If your colors are floats, you could use `{float}::to_bits` to put them in a hashmap since floats don't impl Hash
fn count_colors(
    pixels: &[[u8; 3]],
    map: &mut HashMap<[u8; 3], u64>,
    vec: &mut Vec<([u8; 3], u64)>,
) {
    // Count the colors in an image
    for &color in pixels {
        map.entry(color).and_modify(|c| *c += 1).or_insert(1);
    }

    // Fill a vector with the keys and values from the map
    vec.extend(map.iter().map(|(&k, &v)| (k, v)));

    // Sort the vec by the counts, the most common pixels will be at the end
    // (use `std::cmp::Reverse(a.1)` if you want the most common at the front)
    vec.sort_unstable_by_key(|a| a.1);
}

(You may want to use fxhash instead https://crates.io/crates/fxhash, since it's not a DoS-resistant algorithm.)

From here, you can try using a color distance metric to see if any of the highest count values are close enough to the colors you have in the SVG text to know that you have a match.

If that doesn't work, then Kmeans or some other clustering/segmenting algorithm might be helpful for finding common color pixel groupings. You'd segment the image then count the colors inside each cluster to find the mode color. Different clustering algorithms have pros and cons: some, like Kmeans, don't take locality into account which makes it faster but not always the best results. Some algorithms use locality as part of the distance metric for determining clusters.

Hope this was helpful.

[Tameflame]

I see, thanks very much for the guidance!

I do think I'll need to make use of finding common color pixel groupings, so i can change all colors within a specific distance from a given color. Would you mind sharing any resources I could look at to learning how to change a group of colors within a set color distance? Does this crate have any support for that?

[okaneco]

Does this crate have any support for that?

This crate might be useful for finding the indices of clusters that you could then iterate over. But another clustering algorithm I implemented for finding superpixels called SLIC might be better: it's like kmeans but done in smaller grid cells so it can find edges better.
https://github.com/okaneco/simple_clustering

I would try to use clustering or other computer vision algorithms first before you end up possibly creating your own. I'm not as familiar with the rest of the Rust ecosystem or bindings for this however.

Rolling your own, you could perhaps iterate over the pixels and then do a flood fill using the color distance to determine similar connected clusters. Euclidean distance (or distance squared, to avoid the square root call) can work well. A possible improvement over plain Euclidean distance would be to convert the colors you have to a linear color space like Linear RGB and calculate the distance with those values. I've also used the method mentioned in the Wikipedia article for "redmean" and was happy with the results.
http://www.compuphase.com/cmetric.htm
https://en.wikipedia.org/wiki/Color_difference
After picking a color distance metric, the next step is to iterate on the appropriate threshold until you find one that works for your colors or images.

Types of filters like median or Kuwahara filters might help for pre-processing your image if you decide to write your own search and replace.
https://en.wikipedia.org/wiki/Kuwahara_filter
https://en.wikipedia.org/wiki/Median_filter