JAVA: Converter Imagem para Escala de Cinza

Um exemplo básico de processamento de imagens em JAVA é a conversão de uma imagem colorida para escala de cinza.

Esse exemplo (MainClass) mostra como efetuar a leitura dos pixels de uma imagem, converter seus valores para RGBA (red, green, blue, alpha), modificar os pixels e gravar uma nova imagem.

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class MainClass {

 // converte pixels da imagem para tons de cinza
 public static int[] imageToGray(int image[]) {
  int grayimage[] = new int[image.length];

  for (int i = 0; i < image.length; i++) {
   // extrai a informação RGBA do valor inteiro
   int alpha = (image[i] >> 24) & 0xff;
   int red = (image[i] >> 16) & 0xff;
   int green = (image[i] >> 8) & 0xff;
   int blue = (image[i]) & 0xff;

   // média dos valores RGB para tranformar para
   // escala de cinza
   int mean = (red + green + blue) / 3;

   // converte a informação de rgb para inteiro
   int gray = ((0 << 24) & 0xFF000000) | ((mean << 16) & 0x00FF0000) | ((mean << 8) & 0x0000FF00) | (mean & 0x000000FF);

   // seta o pixel modificado na imagem
   grayimage[i] = gray;
  }

  return grayimage;
 }

 public static void main(String[] args) throws IOException {

  File inputFile = new File("/tmp/tux-ubuntu.jpg");
  BufferedImage buffImage = ImageIO.read(inputFile);

  int w = buffImage.getWidth();
  int h = buffImage.getHeight();

  int rgba[] = new int[w * h];
  // obtem pixels do bufferedImage
  buffImage.getRGB(0, 0, w, h, rgba, 0, w);

  // converte para tons de cinza
  int gray[] = imageToGray(rgba);
  // escreve no bufferedImage
  buffImage.setRGB(0, 0, w, h, gray, 0, w);

  // escreve nova imagem no disco
  ImageIO.write(buffImage, "JPG", new File("/tmp/tux-gray.jpg"));
 }
}

O exemplo de utilização da classe:

JAVA: Varargs

Uma característica muito legal das linguagens orientadas à objetos, em especial do JAVA é o overloading de métodos, onde um mesmo método pode ser invocado usando assinaturas diferentes. Por exemplo, um método com o mesmo nome, mas com uma variável quantidade de argumentos aceitáveis.
Um exemplo poderia ser:

Calc c = new Calc();

c.calcula(10, 35, 34);

c.calcula(3.4, 12);

c.calcula("Triângulo", 56, 23, 21);

No exemplo acima, foi instanciada uma classe chamada Calc, que efetua algum tipo de cálculo qualquer. O objeto c possui um método chamado calcula(), que pode ser chamado de três formas diferentes, onde o nome do método não muda, somente seus argumentos.

O Varargs (Variable Arguments), permite especificar que o método terá múltiplos argumentos do mesmo tipo, sem que haja necessidade de pre-determinar o número exato de argumentos(em tempo de compilação e/ou execução).

Para utilizar o varargs, fazemos uso da elipse (...), onde os três pontos são a chave (keyword) pra varargs. Vejamos e exemplo da classe VargsExample, esta por sua vez é composta de métodos que calculam a média de valores passados com o argumentos. Temos mean(float num1, float num2), que calcula a média de 2 argumentos, um overload do método anterior: mean(float num1, float num2, float num3, float num4); que calcula a média entre quatro argumentos, e por ultimo, temos a utilização de varargs: mean(float... numbers), que permite o cálculo da média para um número indefinido de argumentos, incluindo a passagem de parâmetro como um array primitivo do tipo float.

public class VargsExample {

// método que calcula a média
public float mean(float num1, float num2) {
return (num1 + num2) / 2.0f;
}

// overloading do método que calcula a média
public float mean(float num1, float num2, float num3, float num4) {
return (num1 + num2 + num3 + num4) / 4.0f;
}

// calculo da média usando varargs
public float mean(float... numbers) {
float sum = 0;

for (float n : numbers)
sum += n;

return sum / (float) numbers.length;
}

public static void main(String[] args) {

VargsExample calc = new VargsExample();
// Exemplos de chamadas de métodos

// método de calculo de média
calc.mean(10, 23);

// overloading
calc.mean(10, 20, 30, 40);

// usando varargs que recebe número indeterminado de argumentos
calc.mean(12);
calc.mean(new float[] {12, 45, 78, 34, 21, 34, 54, 8, 9, 12, 87});
calc.mean(0, 2, 1);
calc.mean(9, 5, 7, 10, 4);
}
}

O exemplo apresentado, mostra a flexibilidade que se consegue com o emprego de varargs em determinados métodos. Esse recurso foi introduzido na versão Tiger do JAVA: 1.5.

Adicionar Servidor Tomcat 5.5 como serviço no Ubuntu

Esse post mostra como colocar o servidor web Tomcat 5.5 como serviço no sistema ubuntu linux.
Para isso basta:

Criar o script de inicialização em /etc/init.d/ arquivo: tomcat

# description: Auto-starts tomcat
# processname: tomcat
# pidfile: /var/run/tomcat.pid

case $1 in
start)
  sh /opt/tomcat/bin/startup.sh
  ;;
stop)
  sh /opt/tomcat/bin/shutdown.sh
  ;;
restart)
  sh /opt/tomcat/bin/shutdown.sh
  sh /opt/tomcat/bin/startup.sh
  ;;
esac

exit 0

Em seguida deve-se dar permissão de execução ao arquivo

sudo chmod 755 /etc/init.d/tomcat

O próximo passo é instalar o tomcat como um serviço sistema, o utilitário
update-rc.d é utilizado com esse fim da seguinte forma:

update-rc.d tomcat defaults

Resultado da execução e criação de links efetuado pelo update-rc.d:

Adding system startup for /etc/init.d/tomcat ...
/etc/rc0.d/K20tomcat -> ../init.d/tomcat
/etc/rc1.d/K20tomcat -> ../init.d/tomcat
/etc/rc6.d/K20tomcat -> ../init.d/tomcat
/etc/rc2.d/S20tomcat -> ../init.d/tomcat
/etc/rc3.d/S20tomcat -> ../init.d/tomcat
/etc/rc4.d/S20tomcat -> ../init.d/tomcat
/etc/rc5.d/S20tomcat -> ../init.d/tomcat

A próxima vez que o sistema for reiniciado, o arquivo tomcat (configurado acima) será executado inicializando o servidor tomcat como um serviço.