Java 如何找到图像的主色？

使用java、imagemagick或jmagick，我们能找到图像中占主导地位的颜色吗？

使用普通java，您只需迭代每个像素，并计算每种颜色包含的频率

伪代码：

Map<Color, Integer> color2counter;
for (x : width) {
   for (y : height) {
      color = image.getPixel(x, y)
      occurrences = color2counter.get(color)
      color2counter.put(color, occurrences + 1)
   }
}

Map color2计数器；
用于（x：宽度）{
对于（y：高度）{
颜色=图像.getPixel（x，y）
引用次数=color2counter.get（颜色）
color2counter.put（颜色，出现次数+1）
}
}

在java中迭代每个像素并确定颜色

import java.awt.image.BufferedImage;
import java.io.File;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;


public class ImageTester {


    public static void main(String args[]) throws Exception {
        File file = new File("C:\\Users\\Andrew\\Desktop\\myImage.gif");
        ImageInputStream is = ImageIO.createImageInputStream(file);
        Iterator iter = ImageIO.getImageReaders(is);

        if (!iter.hasNext())
        {
            System.out.println("Cannot load the specified file "+ file);
            System.exit(1);
        }
        ImageReader imageReader = (ImageReader)iter.next();
        imageReader.setInput(is);

        BufferedImage image = imageReader.read(0);

        int height = image.getHeight();
        int width = image.getWidth();

        Map m = new HashMap();
        for(int i=0; i < width ; i++)
        {
            for(int j=0; j < height ; j++)
            {
                int rgb = image.getRGB(i, j);
                int[] rgbArr = getRGBArr(rgb);                
                // Filter out grays....                
                if (!isGray(rgbArr)) {                
                        Integer counter = (Integer) m.get(rgb);   
                        if (counter == null)
                            counter = 0;
                        counter++;                                
                        m.put(rgb, counter);                
                }                
            }
        }        
        String colourHex = getMostCommonColour(m);
        System.out.println(colourHex);
    }


    public static String getMostCommonColour(Map map) {
        List list = new LinkedList(map.entrySet());
        Collections.sort(list, new Comparator() {
              public int compare(Object o1, Object o2) {
                return ((Comparable) ((Map.Entry) (o1)).getValue())
                  .compareTo(((Map.Entry) (o2)).getValue());
              }
        });    
        Map.Entry me = (Map.Entry )list.get(list.size()-1);
        int[] rgb= getRGBArr((Integer)me.getKey());
        return Integer.toHexString(rgb[0])+" "+Integer.toHexString(rgb[1])+" "+Integer.toHexString(rgb[2]);        
    }    

    public static int[] getRGBArr(int pixel) {
        int alpha = (pixel >> 24) & 0xff;
        int red = (pixel >> 16) & 0xff;
        int green = (pixel >> 8) & 0xff;
        int blue = (pixel) & 0xff;
        return new int[]{red,green,blue};

  }
    public static boolean isGray(int[] rgbArr) {
        int rgDiff = rgbArr[0] - rgbArr[1];
        int rbDiff = rgbArr[0] - rgbArr[2];
        // Filter out black, white and grays...... (tolerance within 10 pixels)
        int tolerance = 10;
        if (rgDiff > tolerance || rgDiff < -tolerance) 
            if (rbDiff > tolerance || rbDiff < -tolerance) { 
                return false;
            }                 
        return true;
    }
}

导入java.awt.image.buffereImage；
导入java.io.File；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.HashMap；
导入java.util.Iterator；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Map；
导入javax.imageio.imageio；
导入javax.imageio.ImageReader；
导入javax.imageio.stream.ImageInputStream；
公共类图像测试器{
公共静态void main（字符串args[]）引发异常{
File File=新文件（“C:\\Users\\Andrew\\Desktop\\myImage.gif”）；
ImageInputStream=ImageIO.createImageInputStream（文件）；
迭代器iter=ImageIO.getImageReaders（is）；
如果（！iter.hasNext（））
{
System.out.println（“无法加载指定文件”+文件）；
系统出口（1）；
}
ImageReader=（ImageReader）iter.next（）；
imageReader.setInput（is）；
BuffereImage image=imageReader.read（0）；
int height=image.getHeight（）；
int width=image.getWidth（）；
Map m=新的HashMap（）；
对于（int i=0；i>24）&0xff；
int red=（像素>>16）和0xff；
绿色整数=（像素>>8）&0xff；
蓝色整数=（像素）&0xff；
返回新的int[]{red，green，blue}；
}
公共静态布尔值isGray（int[]rgbArr）{
int rgDiff=rgbArr[0]-rgbArr[1]；
int rbDiff=rgbArr[0]-rgbArr[2]；
//滤除黑色、白色和灰色……（公差在10像素以内）
int公差=10；
if（rgDiff>公差| | rgDiff<-公差）
如果（rbDiff>公差| | rbDiff<-公差）{
返回false；
}                 
返回true；
}
}

假设您使用的是加法配色方案，其中（0,0,0）为黑色，（255,255,255）为白色（如果我弄错了，请纠正我）。此外，如果您只想找到RGB的主色：

我有一个想法，你们中的任何人都可以仔细研究，就是有3个变量，每个变量存储一个RGB值，并将图像中每个像素的适当值添加到每个变量中，然后除以（255*numOfPixels）得到颜色比。然后比较3个比率：红色为60，绿色为0.5，这意味着红色更占优势

---

这只是一个想法，可能需要调整…

这是一个棘手的问题。例如，如果您有一个完全相同颜色的小区域和一个不同颜色的大区域，那么简单地寻找使用最多的颜色不太可能得到您想要的结果。你可以通过定义一组颜色来获得更好的结果，并且对于每一个，你认为是“颜色”的RGB值的范围。 本主题将在ImageMagick对话服务器上详细讨论，例如：

---

另请参见

我刚刚发布了一个非常简单的算法，可以简单地用Java翻译。它被调用并在JavaScript中工作

在这个线程中提出的解决方案可能会被图像中的几个白色字符所抛弃，而我的解决方案实际上是试图找到最突出的颜色，即使所有的像素不是完全相同的颜色

---

如果您觉得有用，请告诉我。

另一方面，我们可以使用颜色小偷库完成这项工作。更多的信息可以找到和查询

---

归功于@svenwoltmann和@Lokeshdhdhakar。

我使用了颜色用作RGB类型的jamagick，但通过这种方式，我只能找到图像的平均颜色。但我有一个想法，我可以裁剪中间的图像，这样我就可以找到那个部分的平均颜色，它将再次提供几乎相同的颜色。我只找到主色调：/@ErçinAkçay如果你想裁剪图像，当然你想在边界处使用主色调。e、 假设你有一个被白色包围的大正方形。你想检测白色的颜色来裁剪它，而不是正方形。你是指图像中使用最多的阴影还是平均颜色？Hi@pieroxy，这看起来很有希望——但对我来说，翻译成Java并不是那么简单——至少在fi上是这样