Поиск доминирующего цвета изображения в Android @drawable

Ответ 1

В Android 5.0 Lollipop был добавлен класс для извлечения полезных цветов из растрового изображения. Класс Палитра, найденный в android.support.v7.graphics, может извлекать следующие цвета:

• Яркий
• Яркая темнота
• Яркий свет
• Приглушенный
• Приглушенный темнота
• Приглушенный свет

На этой странице обучения по Android приведены все детали, необходимые для использования класса (я сам попробовал это сделать в Android Studio, и это было очень просто): http://developer.android.com/training/material/drawables.html#ColorExtract

Цитировать:

Библиотека поддержки Android r21 и выше включает в себя палитру класс, который позволяет вам извлечь выдающиеся цвета из изображения. к распакуйте эти цвета, передайте объект Bitmap в Palette.generate() статический метод в фоновом потоке, куда вы загружаете ваши изображения. Если Вы не можете использовать этот поток, вызовите метод Palette.generateAsync() и вместо этого предоставьте слушателя. *

Вы можете получить заметные цвета из изображения, используя геттер методы в классе Palette, такие как Palette.getVibrantColor.

Чтобы использовать класс Palette в своем проекте, добавьте следующий Gradle зависимость от вашего модуля приложения:

dependencies {
    ...
    implementation 'com.android.support:palette-v7:21.0.+'
}

Or if you're using androidx:

implementation 'androidx.palette:palette:1.0.0'

Если вам нужно использовать generateAsync(), вот как:

Palette.generateAsync(bitmap, new Palette.PaletteAsyncListener() {
    public void onGenerated(Palette palette) {
        // Do something with colors...
    }
});

EDIT: Поскольку вопрос состоит в том, как извлечь цвета из прорисовываемого ресурса, вам сначала нужно преобразовать прорисовку в растровое изображение, чтобы использовать описанную мной технику. К счастью, это довольно просто, используя BitmapFactory:

Bitmap icon = BitmapFactory.decodeResource(context.getResources(),
                                       R.drawable.icon_resource);'

Ответ 2

Существует еще одно решение, оно более приближенное, но если вы не хотите иметь длительную задержку для поиска цвета, он может выполнить эту работу.

public static int getDominantColor(Bitmap bitmap) {
    Bitmap newBitmap = Bitmap.createScaledBitmap(bitmap, 1, 1, true);
    final int color = newBitmap.getPixel(0, 0);
    newBitmap.recycle();
    return color;
}

Ответ 3

Этот класс выполняет итерацию через Bitmap и возвращает самый доминирующий цвет. Не стесняйтесь очищать код, если это необходимо.

public class ImageColour {

String colour;


public ImageColour(Bitmap image) throws Exception {

     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.getPixel(i, j);
                int[] rgbArr = getRGBArr(rgb);                

                if (!isGray(rgbArr)) {   

                        Integer counter = (Integer) m.get(rgb);   
                        if (counter == null)
                            counter = 0;
                        counter++;                                
                        m.put(rgb, counter);       

                }                
            }
        }        

        String colourHex = getMostCommonColour(m);
    }



    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 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];

        int tolerance = 10;

        if (rgDiff > tolerance || rgDiff < -tolerance) 
            if (rbDiff > tolerance || rbDiff < -tolerance) { 

                return false;

            }                

        return true;
    }


public String returnColour() {

    if (colour.length() == 6) {
        return colour.replaceAll("\\s", "");
    } else {
        return "ffffff";
    }
}

чтобы получить шестнадцатеричный просто вызов   returnColour();

Ответ 4

Я написал свои собственные методы, чтобы получить доминирующий цвет:

Метод 1 (Моя техника)

• Уменьшить до ARGB_4444 цветовое пространство
• Вычислить максимальное количество отдельных элементов RGB и получить 3 отличительных максимальных значения

• Сочетание максимальных значений с доминирующим цветом RGB

  public int getDominantColor1(Bitmap bitmap) {
  
  if (bitmap == null)
      throw new NullPointerException();
  
  int width = bitmap.getWidth();
  int height = bitmap.getHeight();
  int size = width * height;
  int pixels[] = new int[size];
  
  Bitmap bitmap2 = bitmap.copy(Bitmap.Config.ARGB_4444, false);
  
  bitmap2.getPixels(pixels, 0, width, 0, 0, width, height);
  
  final List<HashMap<Integer, Integer>> colorMap = new ArrayList<HashMap<Integer, Integer>>();
  colorMap.add(new HashMap<Integer, Integer>());
  colorMap.add(new HashMap<Integer, Integer>());
  colorMap.add(new HashMap<Integer, Integer>());
  
  int color = 0;
  int r = 0;
  int g = 0;
  int b = 0;
  Integer rC, gC, bC;
  for (int i = 0; i < pixels.length; i++) {
      color = pixels[i];
  
      r = Color.red(color);
      g = Color.green(color);
      b = Color.blue(color);
  
      rC = colorMap.get(0).get(r);
      if (rC == null)
          rC = 0;
      colorMap.get(0).put(r, ++rC);
  
      gC = colorMap.get(1).get(g);
      if (gC == null)
          gC = 0;
      colorMap.get(1).put(g, ++gC);
  
      bC = colorMap.get(2).get(b);
      if (bC == null)
          bC = 0;
      colorMap.get(2).put(b, ++bC);
  }
  
  int[] rgb = new int[3];
  for (int i = 0; i < 3; i++) {
      int max = 0;
      int val = 0;
      for (Map.Entry<Integer, Integer> entry : colorMap.get(i).entrySet()) {
          if (entry.getValue() > max) {
              max = entry.getValue();
              val = entry.getKey();
          }
      }
      rgb[i] = val;
  }
  
  int dominantColor = Color.rgb(rgb[0], rgb[1], rgb[2]);
  
  return dominantColor;
   }
  

Метод 2 (старая техника)

• Уменьшить до ARGB_4444 цветовое пространство

• Вычислить появление каждого цвета и найти максимальный цвет как доминирующий цвет

  public int getDominantColor2(Bitmap bitmap) {
  if (bitmap == null)
      throw new NullPointerException();
  
  int width = bitmap.getWidth();
  int height = bitmap.getHeight();
  int size = width * height;
  int pixels[] = new int[size];
  
  Bitmap bitmap2 = bitmap.copy(Bitmap.Config.ARGB_4444, false);
  
  bitmap2.getPixels(pixels, 0, width, 0, 0, width, height);
  
  HashMap<Integer, Integer> colorMap = new HashMap<Integer, Integer>();
  
  int color = 0;
  Integer count = 0;
  for (int i = 0; i < pixels.length; i++) {
      color = pixels[i];
      count = colorMap.get(color);
      if (count == null)
          count = 0;
      colorMap.put(color, ++count);
  }
  
  int dominantColor = 0;
  int max = 0;
  for (Map.Entry<Integer, Integer> entry : colorMap.entrySet()) {
      if (entry.getValue() > max) {
          max = entry.getValue();
          dominantColor = entry.getKey();
      }
  }
  return dominantColor;
  }
  

Ответ 5

Чтобы найти доминирующий/яркий/приглушенный цвет на изображении, используйте палитру:

Импортировать:

implementation 'androidx.palette:palette:1.0.0'

использование:

    val bitmap = BitmapFactory.decodeResource(resources, R.drawable.image)

    Palette.Builder(bitmap).generate { it?.let {  palette ->
        val dominantColor = palette.getDominantColor(ContextCompat.getColor(context!!, R.color.defaultColor))

        // TODO: use dominant color

    } }

Ответ 6

Прокрутите все данные цвета пикселя и сравните значения цвета, игнорируйте все, что является оттенком серого или прозрачного. Я считаю, что именно это делает Microsoft в Windows 7 на основе недавнего сообщения в блоге.

изменить
Сообщение в блоге: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/06/10244432.aspx

Эта ссылка, показывающая, как Chrome выбирает доминирующий цвет, также может быть полезна. http://www.quora.com/Google-Chrome/How-does-Chrome-pick-the-color-for-the-stripes-on-the-Most-visited-page-thumbnails

Ответ 7

Добавить в зависимости

implementation 'androidx.palette:palette:1.0.0'

и..

 AppCompatImageView imageView = findViewById(R.id.image_view);

 Bitmap bitmap = ((BitmapDrawable) imageView.getDrawable()).getBitmap();
 Palette.from(bitmap).generate(palette -> {
      int vibrant = palette.getVibrantColor(0x000000); // <=== color you want
      int vibrantLight = palette.getLightVibrantColor(0x000000);
      int vibrantDark = palette.getDarkVibrantColor(0x000000);
      int muted = palette.getMutedColor(0x000000);
      int mutedLight = palette.getLightMutedColor(0x000000);
      int mutedDark = palette.getDarkMutedColor(0x000000);
 });

Ответ 8

Ни один из других ответов не помог мне, и я не исключил причину проблемы.

Вот что я в итоге использовал:

public static int getDominantColor(Bitmap bitmap) {
    if (bitmap == null) {
        return Color.TRANSPARENT;
    }
    int width = bitmap.getWidth();
    int height = bitmap.getHeight();
    int size = width * height;
    int pixels[] = new int[size];
    //Bitmap bitmap2 = bitmap.copy(Bitmap.Config.ARGB_4444, false);
    bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
    int color;
    int r = 0;
    int g = 0;
    int b = 0;
    int a;
    int count = 0;
    for (int i = 0; i < pixels.length; i++) {
        color = pixels[i];
        a = Color.alpha(color);
        if (a > 0) {
            r += Color.red(color);
            g += Color.green(color);
            b += Color.blue(color);
            count++;
        }
    }
    r /= count;
    g /= count;
    b /= count;
    r = (r << 16) & 0x00FF0000;
    g = (g << 8) & 0x0000FF00;
    b = b & 0x000000FF;
    color = 0xFF000000 | r | g | b;
    return color;
}