Como somar a porcentagem de cor de uma imagem em tons de cinza?

Programação
#1

Tenho a seguinte situação, uma impressora na cor preta, somente. faz uma impressão em uma fola A4, quantos por sento da folha o toner cobril.

Pelos meus cálculos analisando a imagem no computador eu cheguei a conclusão de que teria que ter um código que trabalhasse da seguinte forma, soma-se toda a porcentagem da cor de cada pixel (Ex.: um pixel tem 36% de preto o outro pixel tem 50% de preto, o outro pixel tem 21% de preto, o outro pixel tem 100% de preto).
Em uma imagem que tem 25 pixel no total da imagem. Então somando todas a porcentagem (ex.: 36+50+21+100 = 207 por cento de preto somada de cada pixel).
Então dividimos por 100 que é a escala que queremos te como base, e depois por 25 que é o total de pixel da imagem, temos 0,0828 de cor preta usada na imagem.
Então teria a porcentagem de toner que uma imagem gastaria em porcentagem, correto?
Espero ajuda dos colegas, para desenvolver um código que faça esse calculo.
Grato.

#2

Dá uma ajeitada no seu texto, muitos erros de português. :wink:

Com base na sua explicação, creio que seria algo como o código abaixo:

public class Exemplo {

    public static void main(String[] args) {
        Exemplo programa = new Exemplo();
        programa.executar();
    }

    private void executar() {
        int somaPercentualPreto = 0;
        int[] pixelsColoridos = carregarImagem();
        int quantidade = pixelsColoridos.length;
        for (int i = 0; i < quantidade; i++) {
            int tomCinza = escalaCinza(pixelsColoridos[i]); // se sua imagem já está em escala de cinza, aí não precisaria converter
            somaPercentualPreto += percentualPreto(tomCinza);
        }
        double percentualPreto = somaPercentualPreto / 100.0 / (double) quantidade;
        System.out.println("Total de preto: " + percentualPreto);
    }

    private int percentualPreto(int tomCinza) {
        return 100 - (tomCinza * 100 / 255);
    }

    private int escalaCinza(int rgb) {
        int[] tons = derivar(rgb);
        int r = tons[0];
        int g = tons[1];
        int b = tons[2];
        int cinza = (r + g + b) / 3;
        tons[0] = cinza;
        tons[1] = cinza;
        tons[2] = cinza;
        return integrar(tons);
    }

    private int[] derivar(int rgb) {
        int r = (rgb >> 16) & 0xFF;
        int g = (rgb >> 8) & 0xFF;
        int b = (rgb >> 0) & 0xFF;
        return new int[] { r, g, b };
    }

    private int integrar(int[] rgb) {
        int r = (rgb[0] & 0xFF) << 16;
        int g = (rgb[1] & 0xFF) << 8;
        int b = (rgb[2] & 0xFF) << 0;
        return r | g | b;
    }

    private int[] carregarImagem() {
        // neste método você implementa a carga dos pixels de sua imagem
    }
}