Olá a todos, vim aqui pedir uma ajuda com um código que encontrei na net. Esse código faz o que eu gostaria de fazer ou seja, desenhar por mim em um programa externo.
Segundo o seu autor, ele foi criado há quatro anos atrás pra ser usado no windows vista. Gostaria de uma ajudinha pra que ele funcione no windows atual.
package javaRobotPainter;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.*;
import javax.imageio.ImageIO;
/**
* Quando esta classe é instanciado um bot é criado, que traça um retrato especificado no Microsoft Paint.
* Este programa só foi testado no Windows Vista com o MS pintura versão 6.0.
* <br /> <br />
* NOTA: O atraso entre cada operação e o tempo para iniciar o MS painter pode ter de ser ajustada.
* A tecla de atalho para maximizar a janela, no {@codeinitMsPaint()}, também pode ter de ser alterado.
* Funciona com a versão norueguesa do Vista.
*
* @author teaprog
* @version 1.0, 30/04/12
*/
public class JavaRobotPainter {
/** O tamanho da tela. */
private Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
/** Aonde inicia a pintura sobre o eixo x.*/
private static final int START_POSITION_X = 61;
/** Aonde inicia a pintura sobre o eixo x.*/
private static final int START_POSITION_Y = 94;
/** O tamanho dos rectângulos sendo desenhado*/
private int rectangleSize = 5;
/** As cores deste bot tem à sua disposição.*/
private ArrayList<Color> availableColors = new ArrayList<Color>();
/** A posição de cada cor.*/
private HashMap<Color, Point> colorPosition = new HashMap<Color, Point>();
/** As cores disponíveis.*/
private enum ColorNr {COLOR_ONE, COLOR_TWO};
/** A cor atual selecionada. */
private ColorNr currentColor = ColorNr.COLOR_ONE;
/** As cores selecionadas. (Por cor padrão uma é preto e duas cores são brancas*/
private Color[] selectedColors = new Color[]{new Color(0, 0, 0), new Color(255, 255, 255)};
/** A imagem que vai ser desenhado em MS Paint*/
private BufferedImage image;
/** O processo de pintura do MS Paint.*/
private Process msPaint;
/** O robô que vai desenhar a imagem.*/
private Robot robot;
/** O atraso entre cada operação bot. Isto pode ter que ser ajustada para diferentes computadores.*/
private int robotDelay = 1;
/** O tempo que é necessário para iniciar MS Paint. Isto pode ter que ser ajustada para diferentes computadores. */
private long timeRequiredToStartMsPaint = 1000;
/**
* Executa MS Paint e começa a desenhar.
*
* @throws AWTException
* @throws IOException
*/
public JavaRobotPainter() throws AWTException, IOException {
image = ImageIO.read(new File("img/image.jpg"));
robot = new Robot();
robot.setAutoDelay(robotDelay);
initMsPaint();
startPainting();
}
/**
* Executa MS Paint, define os atributos da imagem, inicializa as cores disponíveis
* E escolhe um retângulo preenchido como desenho de utilidade.
*
* @throws IOException
* @throws InterruptedException
*/
private void initMsPaint() throws IOException {
msPaint = Runtime.getRuntime().exec("mspaint.exe");
// wait until mspaint.exe starts
long time = System.currentTimeMillis();
while(System.currentTimeMillis() - time < timeRequiredToStartMsPaint);
// maximiza a janela
// NOTA: as teclas de atalho depende da versão do seu windows.
robot.keyPress(KeyEvent.VK_ALT);
robot.keyPress(KeyEvent.VK_SPACE);
robot.keyPress(KeyEvent.VK_X);
robot.keyRelease(KeyEvent.VK_X);
robot.keyRelease(KeyEvent.VK_SPACE);
robot.keyRelease(KeyEvent.VK_ALT);
setAttributes(image.getWidth(), image.getHeight());
initColors();
chooseFilledRectangle();
}
/**
* Define o tamanho da tela em MS Paint.
* @param width - A largura da imagem a ser desenhada.
* @param height - A altura da imagem a ser tirada.
*/
private void setAttributes(int width, int height) {
// Se a largura ou a altura é muito grande, então o programa sai.
if (width + START_POSITION_X > screenSize.width || height + START_POSITION_Y > screenSize.height) {
System.out.println("A largura ou altura é muito grande!");
msPaint.destroy();
System.exit(0);
}
// Abre os atributos da janela
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_E);
robot.keyRelease(KeyEvent.VK_E);
robot.keyRelease(KeyEvent.VK_CONTROL);
// captura a largura e a altura
setCliboard(new Integer(width).toString());
pasteDataFromClipboard();
robot.keyPress(KeyEvent.VK_TAB);
robot.keyRelease(KeyEvent.VK_TAB);
setCliboard(new Integer(height).toString());
pasteDataFromClipboard();
robot.keyPress(KeyEvent.VK_ENTER);
robot.keyRelease(KeyEvent.VK_ENTER);
}
/**
* Inicializa as cores disponíveis. Isso é as 28 cores no painel de cores acima da tela.
*/
private void initColors() {
int interval = 16; // A distância que o mouse pecorre para pintar cada cor.
int startX = 95; // A posição X para pintar a primeira cor no painel.
int startY = 55; // A posição y para pintar a primeira cor no painel.
// Localiza as cores e os adiciona à avaibleColors, e coloca a posição da cor no colorPosition.
for (int i = 0; i < 14; i++) {
for (int j = 0; j < 2; j++) {
Color color = robot.getPixelColor(startX + i*interval, startY + j*interval);
availableColors.add(color);
colorPosition.put(color, new Point(startX + i*interval, startY + j*interval));
}
}
}
/**
* Define um retângulo preenchido como ferramenta de desenho.
*/
private void chooseFilledRectangle() {
// choose rectangle
robot.mouseMove(15, 210);
robot.mousePress(InputEvent.BUTTON1_MASK);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
// choose filled
robot.mouseMove(15, 300);
robot.mousePress(InputEvent.BUTTON1_MASK);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
}
/**
* Pressiona as teclas "ctrl" e "v" para colar o conteúdo da área de transferência.
*/
private void pasteDataFromClipboard() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_CONTROL);
}
/**
* Define o clipboard para a cadeia especificada.
* @param string - A string a ser copiado para área de transferência.
*/
public void setCliboard(String string) {
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
clipboard.setContents(new StringSelection(string), null);
}
/**
* Start para pintar a imagem no MS Paint.
* Se o usuário mover o mouse, em seguida, o programa termina.
*/
private void startPainting() {
Point point = new Point(MouseInfo.getPointerInfo().getLocation().x, MouseInfo.getPointerInfo().getLocation().y);
for (int i = START_POSITION_Y; i-START_POSITION_Y < image.getHeight(); i += rectangleSize) {
for (int j = START_POSITION_X; j-START_POSITION_X < image.getWidth(); j += rectangleSize) {
// if user moves the mouse then the program terminates
if (point.x != MouseInfo.getPointerInfo().getLocation().x || point.y != MouseInfo.getPointerInfo().getLocation().y)
System.exit(0);
setColor(new Color(image.getRGB(j-START_POSITION_X, i-START_POSITION_Y)));
int mouseButton = (currentColor == ColorNr.COLOR_ONE) ? InputEvent.BUTTON1_MASK : InputEvent.BUTTON3_MASK;
robot.mouseMove(j, i);
robot.mousePress(mouseButton);
robot.mouseMove(j + rectangleSize, i + rectangleSize);
robot.mouseRelease(mouseButton);
// definir a posição do último ponto em que o mouse estava
point.setLocation(j + rectangleSize, i + rectangleSize);
}
}
}
/**
* Muda a cor se necessário, i.e. se a cor não está em {@code selectedColors[0]} ou {@code selectedColors[1]}.
* @param pixelColor - A cor do pixel, a partir da imagem, onde o programa tem de encontrar uma cor aproximada na {@code availableColors}
*/
private void setColor(Color pixelColor) {
Color mostAccurateColor = findMostAccurateColorAvailable(pixelColor);
if (selectedColors[0].equals(mostAccurateColor)) {
currentColor = ColorNr.COLOR_ONE;
}
else if (selectedColors[1].equals(mostAccurateColor)) {
currentColor = ColorNr.COLOR_TWO;
}
else { // If the color is not in selectedColors, then select new color from the panel.
Point p = colorPosition.get(mostAccurateColor);
int mouseButton;
if (currentColor == ColorNr.COLOR_ONE) {
mouseButton = InputEvent.BUTTON3_MASK;
currentColor = ColorNr.COLOR_TWO;
selectedColors[1] = mostAccurateColor;
}
else {
mouseButton = InputEvent.BUTTON1_MASK;
currentColor = ColorNr.COLOR_ONE;
selectedColors[0] = mostAccurateColor;
}
robot.mouseMove(p.x, p.y);
robot.mousePress(mouseButton);
robot.mouseRelease(mouseButton);
}
}
/**
* Localiza a cor mais precisa que está disponível em {@code availableColors
* @param pixelColor - A cor dos pixels na imagem.
* @return a cor mais precisa de {@code availableColors}
*/
private Color findMostAccurateColorAvailable(Color pixelColor) {
double minError = Double.MAX_VALUE;
int bestColorIndex = 0;
for (int i = 0; i < availableColors.size(); i++) {
int r1 = availableColors.get(i).getRed();
int g1 = availableColors.get(i).getGreen();
int b1 = availableColors.get(i).getBlue();
int r2 = pixelColor.getRed();
int g2 = pixelColor.getGreen();
int b2 = pixelColor.getBlue();
// 2-norm distance
double error = Math.sqrt((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2));
if (error < minError) {
minError = error;
bestColorIndex = i;
}
}
return availableColors.get(bestColorIndex);
}
/**
* The main method.
*
* @param args
* @throws AWTException
* @throws IOException
* @throws InterruptedException
*/
public static void main(String[] args) throws AWTException, IOException {
new JavaRobotPainter();
}
}