import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.WritableRaster;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;
import org.neuroph.core.NeuralNetwork;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.data.DataSetRow;
import org.neuroph.core.learning.error.MeanSquaredError;
import org.neuroph.nnet.ConvolutionalNetwork;
import org.neuroph.nnet.learning.ConvolutionalBackpropagation;
public class Schach {
private static int input_width = 192;
private static int input_height = 108;
private static int n1 = input_width * input_height;
private static double n2 = 0xFFFFFF;
private static String background_image = ".../back1.png";
private static String board1_image = ".../brett2.jpg";
private static String board2_image = ".../brett3.jpg";
public static BufferedImage resize(BufferedImage img, int newW, int newH) {
Image tmp = img.getScaledInstance(newW, newH, Image.SCALE_SMOOTH);
BufferedImage dimg = new BufferedImage(newW, newH, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = dimg.createGraphics();
g2d.drawImage(tmp, 0, 0, null);
g2d.dispose();
return dimg;
}
public static BufferedImage deepCopy(BufferedImage img) {
ColorModel cm = img.getColorModel();
boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
WritableRaster raster = img.copyData(null);
return new BufferedImage(cm, raster, isAlphaPremultiplied, null);
}
public static BufferedImage createTestImage(BufferedImage back, BufferedImage board, int x2, int y2) {
BufferedImage org = deepCopy(back);
for (int x = 0; x < board.getWidth(); x++) {
for (int y = 0; y < board.getHeight(); y++) {
org.setRGB(x + x2, y + y2, board.getRGB(x, y));
}
}
return resize(org, input_width, input_height);
}
public static double[] getInput(BufferedImage test) {
double[] a = new double[test.getWidth() * test.getHeight()];
for (int i = 0; i < a.length; i++) {
a[i] = test.getRGB(i % test.getWidth(), i / test.getWidth()) / n2;
}
return a;
}
public static double[] getOutput(int x, int y, int w, int h) {
return new double[] { x / 10.0 / input_width, y / 10.0 / input_width, w / 10.0 / input_width };
}
public static void evolveOutput(double[] a) {
a[0] = Math.round(a[0] * 10.0 * input_width);
a[1] = Math.round(a[1] * 10.0 * input_width);
a[2] = Math.round(a[2] * 10.0 * input_width);
}
public static NeuralNetwork<ConvolutionalBackpropagation> getPositionFindingCNN() throws IOException {
int kernel_width = 3;
int number_of_neurons = 3;
int number_of_feature_maps_in_1st_layer = 8;
int number_of_feature_maps_in_2nd_layer = 4;
int number_of_feature_maps_in_3rd_layer = 2;
NeuralNetwork<ConvolutionalBackpropagation> cnn = new ConvolutionalNetwork.Builder()
.withInputLayer(input_width, input_height, 1)
.withConvolutionLayer(kernel_width, kernel_width, number_of_feature_maps_in_1st_layer)
.withPoolingLayer(2, 2)
.withConvolutionLayer(kernel_width, kernel_width, number_of_feature_maps_in_2nd_layer)
.withPoolingLayer(2, 2)
.withConvolutionLayer(kernel_width, kernel_width, number_of_feature_maps_in_3rd_layer)
.withFullConnectedLayer(number_of_neurons)
.build();
System.out.println(cnn.getInputsCount());
System.out.println(cnn.getOutputsCount());
DataSet trainSet = new DataSet(n1, number_of_neurons);
BufferedImage back = ImageIO.read(new File(background_image));
BufferedImage board1 = ImageIO.read(new File(board1_image));
BufferedImage board2 = ImageIO.read(new File(board2_image));
Random random = new Random(0);
for (int i = 0; i < 12; i++) {
int x = random.nextInt(back.getWidth() - board1.getWidth() + 1);
int y = random.nextInt(back.getHeight() - board1.getHeight() + 1);
BufferedImage testImg;
if (random.nextInt(2) == 0) {
testImg = createTestImage(back, board1, x, y);
} else {
testImg = createTestImage(back, board2, x, y);
}
double[] input = getInput(testImg);
double[] output = getOutput(x, y, board1.getWidth(), board1.getHeight());
DataSetRow dst = new DataSetRow(input, output);
trainSet.add(dst);
System.out.println(x + " " + y + " at " + Arrays.toString(dst.getDesiredOutput()) + " added");
}
int maxIter = 75;
double maxError = 0.00001;
double learningRate = 0.0001;
ConvolutionalBackpropagation backpropagation = new ConvolutionalBackpropagation();
backpropagation.setLearningRate(learningRate);
backpropagation.setMaxError(maxError);
backpropagation.setMaxIterations(maxIter);
backpropagation.setErrorFunction(new MeanSquaredError());
System.out.println("MaxIterations : " + backpropagation.getMaxIterations());
System.out.println("LearningRate : " + backpropagation.getLearningRate());
System.out.println("MaxError : " + backpropagation.getMaxError());
cnn.setLearningRule(backpropagation);
cnn.learn(trainSet);
return cnn;
}
public static void main(String[] args) throws IOException {
NeuralNetwork<ConvolutionalBackpropagation> cnn = getPositionFindingCNN();
BufferedImage back = ImageIO.read(new File(background_image));
BufferedImage board1 = ImageIO.read(new File(board1_image));
BufferedImage testImg = createTestImage(back, board1, 127, 446);
double[] input = getInput(testImg);
cnn.setInput(input);
cnn.calculate();
double[] output = cnn.getOutput();
evolveOutput(output);
System.out.println(Arrays.toString(output));
testImg = createTestImage(back, board1, 100, 100);
input = getInput(testImg);
cnn.setInput(input);
cnn.calculate();
output = cnn.getOutput();
evolveOutput(output);
System.out.println(Arrays.toString(output));
}
}
