public static BufferedImage ensureRgb(BufferedImage src) {

if (src.getType() == BufferedImage.TYPE_INT_RGB) {

return src;

}

BufferedImage out = new BufferedImage(src.getWidth(), src.getHeight(), BufferedImage.TYPE_INT_RGB);

Graphics2D g = out.createGraphics();

g.drawImage(src, 0, 0, null);

g.dispose();

return out;

}

public static BufferedImage paraPB(BufferedImage image) {

int altura = image.getHeight();

int largura = image.getWidth();

for (int lin = 0; lin < largura; lin++) {

for (int col = 0; col < altura; col++) {

int pixel = image.getRGB(lin, col);

Color cor = new Color(pixel);

int pixelCorCinza = (int) ((cor.getRed() * .3) + (cor.getGreen() * .6) + (cor.getBlue() * .1));

Color novaCor = new Color(pixelCorCinza);

Color cinza = new Color(novaCor.getBlue(), novaCor.getBlue(), novaCor.getBlue());

image.setRGB(lin, col, cinza.getRGB());

}

}

return image;

}

public static BufferedImage binarizacao(BufferedImage image, int limiar) {

BufferedImage imagemBin = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_3BYTE_BGR);

int altura = imagemBin.getHeight();

int largura = imagemBin.getWidth();

for (int lin = 0; lin < largura; lin++) {

for (int col = 0; col < altura; col++) {

int pixel = image.getRGB(lin, col);

Color cor = new Color(pixel);

if (cor.getRed() >= limiar) {

imagemBin.setRGB(lin, col, Color.white.getRGB());

} else {

imagemBin.setRGB(lin, col, Color.black.getRGB());

}

}

}

return imagemBin;

}

public static double[][] gerarKernel(int tamanhoLado) {

double[][] kernel = new double[tamanhoLado][tamanhoLado];

double peso = 1.0 / (tamanhoLado * tamanhoLado);

for (int i = 0; i < tamanhoLado; i++) {

for (int j = 0; j < tamanhoLado; j++) {

kernel[i][j] = peso;

}

}

return kernel;

}

public static BufferedImage aplicarConvolucao(BufferedImage imagem, double[][] kernel) {

int width = imagem.getWidth();

int height = imagem.getHeight();

int tamanhoLado = kernel.length;

int deslocamento = tamanhoLado / 2;

BufferedImage out = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

for (int y = deslocamento; y < height - deslocamento; y++) {

for (int x = deslocamento; x < width - deslocamento; x++) {

double sumR = 0;

double sumG = 0;

double sumB = 0;

for (int ky = 0; ky < tamanhoLado; ky++) {

for (int kx = 0; kx < tamanhoLado; kx++) {

int sampleX = x + (kx - deslocamento);

int sampleY = y + (ky - deslocamento);

Color c = new Color(imagem.getRGB(sampleX, sampleY));

double peso = kernel[ky][kx];

sumR += c.getRed() * peso;

sumG += c.getGreen() * peso;

sumB += c.getBlue() * peso;

}

}

int r = Math.min(255, Math.max(0, (int) Math.round(sumR)));

int g = Math.min(255, Math.max(0, (int) Math.round(sumG)));

int b = Math.min(255, Math.max(0, (int) Math.round(sumB)));

out.setRGB(x, y, new Color(r, g, b).getRGB());

}

}

return out;

}

public static BufferedImage filtroMedia(BufferedImage imagem, int tamanhoLado) {

double[][] kernelMedia = gerarKernel(tamanhoLado);

return aplicarConvolucao(imagem, kernelMedia);

}

public static BufferedImage aplicarFiltro(BufferedImage imagem, double[] filtro, boolean usarValorAbsoluto) {

int width = imagem.getWidth();

int height = imagem.getHeight();

BufferedImage out = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

for (int col = 1; col < height - 1; col++) {

for (int lin = 1; lin < width - 1; lin++) {

double sumR = 0;

double sumG = 0;

double sumB = 0;

int index = 0;

for (int fCol = -1; fCol <= 1; fCol++) {

for (int fLin = -1; fLin <= 1; fLin++) {

Color c = new Color(imagem.getRGB(lin + fLin, col + fCol));

sumR += c.getRed() * filtro[index];

sumG += c.getGreen() * filtro[index];

sumB += c.getBlue() * filtro[index];

index++;

}

}

int r;

int g;

int b;

if (usarValorAbsoluto) {

r = Math.min(255, Math.max(0, (int) Math.abs(sumR)));

g = Math.min(255, Math.max(0, (int) Math.abs(sumG)));

b = Math.min(255, Math.max(0, (int) Math.abs(sumB)));

} else {

r = Math.min(255, Math.max(0, (int) Math.round(sumR)));

g = Math.min(255, Math.max(0, (int) Math.round(sumG)));

b = Math.min(255, Math.max(0, (int) Math.round(sumB)));

}

out.setRGB(lin, col, new Color(r, g, b).getRGB());

}

}

return out;

}

public static BufferedImage aplicarFiltroDuplo(BufferedImage imagem, double[] filtroH, double[] filtroV) {

int width = imagem.getWidth();

int height = imagem.getHeight();

BufferedImage out = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

for (int col = 1; col < height - 1; col++) {

for (int lin = 1; lin < width - 1; lin++) {

double sumHr = 0;

double sumHg = 0;

double sumHb = 0;

double sumVr = 0;

double sumVg = 0;

double sumVb = 0;

int idx = 0;

for (int fCol = -1; fCol <= 1; fCol++) {

for (int fLin = -1; fLin <= 1; fLin++) {

Color c = new Color(imagem.getRGB(lin + fLin, col + fCol));

sumHr += c.getRed() * filtroH[idx];

sumHg += c.getGreen() * filtroH[idx];

sumHb += c.getBlue() * filtroH[idx];

sumVr += c.getRed() * filtroV[idx];

sumVg += c.getGreen() * filtroV[idx];

sumVb += c.getBlue() * filtroV[idx];

idx++;

}

}

double magR = Math.sqrt(sumHr * sumHr + sumVr * sumVr);

double magG = Math.sqrt(sumHg * sumHg + sumVg * sumVg);

double magB = Math.sqrt(sumHb * sumHb + sumVb * sumVb);

int r = Math.min(255, Math.max(0, (int) Math.round(magR)));

int g = Math.min(255, Math.max(0, (int) Math.round(magG)));

int b = Math.min(255, Math.max(0, (int) Math.round(magB)));

out.setRGB(lin, col, new Color(r, g, b).getRGB());

}

}

return out;

}

public static BufferedImage filtroNitidez(BufferedImage imagem) {

double[] nitidez = {0, -1, 0, -1, 5, -1, 0, -1, 0};

return aplicarFiltro(imagem, nitidez, false);

}

public static BufferedImage filtroPrewittHorizontal(BufferedImage imagem) {

double[] prewittHorizontal = {-1, 0, 1, -1, 0, 1, -1, 0, 1};

return aplicarFiltro(imagem, prewittHorizontal, true);

}

public static BufferedImage filtroPrewittVertical(BufferedImage imagem) {

double[] prewittVertical = {-1, -1, -1, 0, 0, 0, 1, 1, 1};

return aplicarFiltro(imagem, prewittVertical, true);

}

public static BufferedImage filtroSobelHorizontal(BufferedImage imagem) {

double[] sobelHorizontal = {-1, 0, 1, -2, 0, 2, -1, 0, 1};

return aplicarFiltro(imagem, sobelHorizontal, true);

}

public static BufferedImage filtroSobelVertical(BufferedImage imagem) {

double[] sobelVertical = {-1, -2, -1, 0, 0, 0, 1, 2, 1};

return aplicarFiltro(imagem, sobelVertical, true);

}

public static BufferedImage filtroLaplace(BufferedImage imagem) {

double[] laplace = {0, -1, 0, -1, 4, -1, 0, -1, 0};

return aplicarFiltro(imagem, laplace, false);

}

public static BufferedImage filtroGaussiano(BufferedImage imagem) {

double[] gauss = {

1.0 / 16, 2.0 / 16, 1.0 / 16,

2.0 / 16, 4.0 / 16, 2.0 / 16,

1.0 / 16, 2.0 / 16, 1.0 / 16

};

return aplicarFiltro(imagem, gauss, false);

}

public static BufferedImage filtroSobelDuplo(BufferedImage imagem) {

double[] sobelGx = {-1, 0, 1, -2, 0, 2, -1, 0, 1};

double[] sobelGy = {-1, -2, -1, 0, 0, 0, 1, 2, 1};

return aplicarFiltroDuplo(imagem, sobelGx, sobelGy);

}

public static BufferedImage filtroPrewittDuplo(BufferedImage imagem) {

double[] prewittH = {-1, 0, 1, -1, 0, 1, -1, 0, 1};

double[] prewittV = {-1, -1, -1, 0, 0, 0, 1, 1, 1};

return aplicarFiltroDuplo(imagem, prewittH, prewittV);

}

public static BufferedImage rotacionarImagem(BufferedImage imagem, double angulo) {

int largura = imagem.getWidth();

int altura = imagem.getHeight();

double radianos = Math.toRadians(angulo);

double seno = Math.sin(radianos);

double cosseno = Math.cos(radianos);

int novaLargura = (int) Math.ceil(Math.abs(largura * cosseno) + Math.abs(altura * seno));

int novaAltura = (int) Math.ceil(Math.abs(largura * seno) + Math.abs(altura * cosseno));

BufferedImage imagemRotacionada = new BufferedImage(novaLargura, novaAltura, BufferedImage.TYPE_INT_RGB);

double centroColuna = largura / 2.0;

double centroLinha = altura / 2.0;

double novoCentroColuna = novaLargura / 2.0;

double novoCentroLinha = novaAltura / 2.0;

for (int linha = 0; linha < altura; linha++) {

for (int coluna = 0; coluna < largura; coluna++) {

double deslocamentoColuna = coluna - centroColuna;

double deslocamentoLinha = linha - centroLinha;

int novaColuna = (int) Math.round(deslocamentoColuna * cosseno - deslocamentoLinha * seno + novoCentroColuna);

int novaLinha = (int) Math.round(deslocamentoColuna * seno + deslocamentoLinha * cosseno + novoCentroLinha);

if (novaColuna >= 0 && novaColuna < novaLargura && novaLinha >= 0 && novaLinha < novaAltura) {

int cor = imagem.getRGB(coluna, linha);

imagemRotacionada.setRGB(novaColuna, novaLinha, cor);

}

}

}

return imagemRotacionada;

}

public static BufferedImage aplicarRuidoSalPimenta(BufferedImage imagem, double intensidade) {

int width = imagem.getWidth();

int height = imagem.getHeight();

BufferedImage imagemComRuido = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

ThreadLocalRandom rnd = ThreadLocalRandom.current();

for (int y = 0; y < height; y++) {

for (int x = 0; x < width; x++) {

Color corOriginal = new Color(imagem.getRGB(x, y));

double valorAleatorio = rnd.nextDouble();

if (valorAleatorio < intensidade / 2.0) {

imagemComRuido.setRGB(x, y, Color.BLACK.getRGB());

} else if (valorAleatorio < intensidade) {

imagemComRuido.setRGB(x, y, Color.WHITE.getRGB());

} else {

imagemComRuido.setRGB(x, y, corOriginal.getRGB());

}

}

}

return imagemComRuido;

}

public static BufferedImage aplicarRuidoGaussiano(BufferedImage imagem, double desvioPadrao) {

int width = imagem.getWidth();

int height = imagem.getHeight();

BufferedImage imagemComRuido = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

ThreadLocalRandom rnd = ThreadLocalRandom.current();

for (int y = 0; y < height; y++) {

for (int x = 0; x < width; x++) {

Color cor = new Color(imagem.getRGB(x, y));

int vermelho = limitar(cor.getRed() + (int) Math.round(rnd.nextGaussian() * desvioPadrao));

int verde = limitar(cor.getGreen() + (int) Math.round(rnd.nextGaussian() * desvioPadrao));

int azul = limitar(cor.getBlue() + (int) Math.round(rnd.nextGaussian() * desvioPadrao));

Color novaCor = new Color(vermelho, verde, azul);

imagemComRuido.setRGB(x, y, novaCor.getRGB());

}

}

return imagemComRuido;

}

private static int limitar(int value) {

return Math.max(0, Math.min(255, value));

}