Otsu Filter

package projeto.imagem;

public class OtsuFilter {

    public double getOtsuThreshold(int[] grayScaleValues) {

        int[] n = getHistograma(grayScaleValues);
        double[] p = getProbabilidades(n, grayScaleValues.length);
        double[] Wo = getWo(p);
        double W = getW(p);
        double[] W1 = getW1(Wo, W);
        double UT = getUT(p);
        double[] Ut = getUt(p);
        double[] Uo = getUo(Ut, Wo);
        double[] U1 = getU1(UT, Ut, Uo);
        double sigmaSqrT = getSigmaSqrT(UT, p);
        double[] sigmaSqrBt = getSigmaSqrBt(Wo, W1, U1, Uo);
        double[] eta = getEta(sigmaSqrBt, sigmaSqrT);

        return getMaxIndex(eta);

    }

    private int[] getHistograma(int[] grayScaleValues) {
        int[] histograma = new int[256];

        for (int i = 0; i < grayScaleValues.length; i++) {
            histograma[grayScaleValues[i]]++;
        }
        return histograma;
    }

    private double[] getProbabilidades(int[] histograma, int totalPixels) {

        double[] probabilidade = new double[histograma.length];

        for (int i = 0; i < probabilidade.length; i++) {
            probabilidade[i] = ((double) histograma[i]) / ((double) totalPixels);
        }

        return probabilidade;
    }

    private double[] getWo(double[] probabilidade) {

        double[] Wo = new double[probabilidade.length];
        Wo[0] = probabilidade[0];

        for (int i = 1; i < Wo.length; i++) {
            Wo[i] = Wo[i - 1] + probabilidade[i];
        }

        return Wo;
    }

    private double getW(double[] probabilidade) {

        double W = 0;

        for (int i = 0; i < probabilidade.length; i++) {
            W += probabilidade[i];
        }

        return W;
    }

    private double[] getW1(double[] Wo, double W) {

        double[] W1 = new double[Wo.length];

        for (int i = 0; i < W1.length; i++) {
            W1[i] = W - Wo[i];
        }

        return W1;
    }

    private double getUT(double[] probabilidade) {

        double UT = 0;

        for (int i = 0; i < probabilidade.length; i++) {
            UT += (((double) i) * probabilidade[i]);
        }

        return UT;

    }

    private double[] getUt(double[] probabilidade) {

        double[] Ut = new double[probabilidade.length];

        Ut[0] = 0;
        for (int i= 1; i < probabilidade.length; i++) {
            Ut[i] = Ut[i - 1] + (((double) i) * probabilidade[i]);
        }

        return Ut;
    }

    private double[] getUo(double[] Ut, double[] Wo) {

        double[] Uo = new double[Ut.length];

        for (int i = 0; i < Ut.length; i++) {
            Uo[i] = Ut[i] / Wo[i];
        }

        return Uo;

    }

    private double[] getU1(double UT, double[] Ut, double[] Uo) {

        double[] U1 = new double[Ut.length];

        for (int i = 0; i < U1.length; i++) {
            U1[i] = (UT - Ut[i]) / (1 - Uo[i]);
        }

        return U1;

    }

    private double getSigmaSqrT(double UT, double[] probability) {

        double sigmaSqrT = 0;

        for (int i = 0; i < probability.length; i++) {
            sigmaSqrT += (Math.pow((i - UT), 2) * probability[i]);
        }

        return sigmaSqrT;

    }

    private double[] getSigmaSqrBt(double[] Wo, double[] W1, double[] U1, double[] Uo) {
        double sigmaSqrBt[] = new double[Wo.length];

        for (int i = 0; i < sigmaSqrBt.length; i++) {
            sigmaSqrBt[i] = Wo[i] * W1[i] * Math.pow((U1[i] - Uo[i]), 2);
        }

        return sigmaSqrBt;
    }

    private int getMaxIndex(double[] array) {

        int maxI = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[maxI] < array[i]) {
                maxI = i;
            }
        }
        return maxI;

    }

    private double[] getEta(double[] sigmaSqrBt, double sigmaSqrT) {
        double eta[] = new double[sigmaSqrBt.length];
        for (int i = 0; i < sigmaSqrBt.length; i++) {
            eta[i] = sigmaSqrBt[i] / sigmaSqrT;
        }
        return eta;
    }
}