Eu encontrei um código pra um projeto que estou desenvolvendo no vídeo ele funciona normal, mas quando tento compila-lo ele não funciona.
No final do código o método main chama a classe principal, será que o erro está aí?
public static void main(String[] args) throws AWTException, IOException {
new JavaRobotPainter();
}Cara, dê mais detalhes sobre o seu problema.
Me diz uma coisa, tem como eu chamar a classe principal pelo método principal main? Esse trecho está no fim do código.
public static void main(String[] args) throws AWTException, IOException {
new JavaRobotPainter();
}Vou tentar mandar todo o código
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;
/**
* When this class is instantiated a bot is created, that draws a specified picture in Microsoft Paint.
* This program has only been tested on Windows Vista with MS Paint version 6.0.
* <br /><br />
* NOTE: The delay between each operation and the time to start MS Paint may have to be adjusted.
* The shortcut key to maximize the window, in {@code initMsPaint()}, may also have to be changed.
* It works with the Norwegian version of Vista.
*
* @author teaprog
* @version 1.0, 30/04/12
*/
public class JavaRobotPainter {
/** The size of the screen. */
private Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
/** Where to start painting on the x-axis. */
private static final int START_POSITION_X = 61;
/** Where to start painting on the y-axis. */
private static final int START_POSITION_Y = 94;
/** The size of the rectangles being drawn. */
private int rectangleSize = 5;
/** The colors this bot has at its disposal. */
private ArrayList<Color> availableColors = new ArrayList<Color>();
/** The position for each color. */
private HashMap<Color, Point> colorPosition = new HashMap<Color, Point>();
/** The colors available. */
private enum ColorNr {COLOR_ONE, COLOR_TWO};
/** The current color selected. */
private ColorNr currentColor = ColorNr.COLOR_ONE;
/** The selected colors. (By default color one is black and color two is white) */
private Color[] selectedColors = new Color[]{new Color(0, 0, 0), new Color(255, 255, 255)};
/** The image that is going to be drawn in MS Paint. */
private BufferedImage image;
/** The process of MS Paint. */
private Process msPaint;
/** The robot that is going to draw the image. */
private Robot robot;
/** The delay between each bot operation. This may have to be adjusted for different computers. */
private int robotDelay = 1;
/** The time that is required to start MS Paint. This may have to be adjusted for different computers. */
private long timeRequiredToStartMsPaint = 1000;
/**
* Executes MS Paint and starts drawing.
*
* @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();
}
/**
* Executes MS Paint, sets the attributes of the picture, initializes the available colors
* and chooses a filled rectangle as drawing utility.
*
* @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);
// maximize the window
// NOTE: the shortcut may vary, depending on the language your windows version has
robot.keyPress(KeyEvent.VK_ALT);
robot.keyPress(KeyEvent.VK_SPACE);
robot.keyPress(KeyEvent.VK_M);
robot.keyRelease(KeyEvent.VK_M);
robot.keyRelease(KeyEvent.VK_SPACE);
robot.keyRelease(KeyEvent.VK_ALT);
setAttributes(image.getWidth(), image.getHeight());
initColors();
chooseFilledRectangle();
}
/**
* Sets the canvas size in MS Paint.
*
* @param width - The width of the image to be drawn.
* @param height - The height of the image to be drawn.
*/
private void setAttributes(int width, int height) {
// if the width or height is too large then exit program
if (width + START_POSITION_X > screenSize.width || height + START_POSITION_Y > screenSize.height) {
System.out.println("The width or height is too large!");
msPaint.destroy();
System.exit(0);
}
// open attributes window
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_E);
robot.keyRelease(KeyEvent.VK_E);
robot.keyRelease(KeyEvent.VK_CONTROL);
// set width and height
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);
}
/**
* Initializes the available colors. That is the 28 colors in the color panel above the canvas.
*/
private void initColors() {
int interval = 16; // The distance the mouse is going to be moved from each color.
int startX = 95; // The x position to the first color in the panel.
int startY = 55; // The y position to the first color in the panel.
// Finds the colors and adds them to avaibleColors, and puts the color position in 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));
}
}
}
/**
* Sets a filled rectangle as drawing tool.
*/
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);
}
/**
* Presses the keys "Ctrl" and "V" to paste the content from the clipboard.
*/
private void pasteDataFromClipboard() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_CONTROL);
}
/**
* Sets the cliboard to the specified string.
*
* @param string - The string to be copied into clipboard.
*/
public void setCliboard(String string) {
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
clipboard.setContents(new StringSelection(string), null);
}
/**
* Starts painting the image in MS Paint.
* If the user moves the mouse then the program terminates.
*/
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);
// set the position of the last point where the mouse was
point.setLocation(j + rectangleSize, i + rectangleSize);
}
}
}
/**
* Changes the color if necessary, i.e. if the color is not in {@code selectedColors[0]} or {@code selectedColors[1]}.
*
* @param pixelColor - The pixel color, from the image, where the program has to find an approximated color in {@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);
}
}
/**
* Finds the most accurate color that is available in {@code availableColors}.
*
* @param pixelColor - The pixel color in the image.
* @return the most accurate color from {@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();
}
}