diff --git a/src/main/java/Enums/DirectionFRL.java b/src/main/java/Enums/DirectionFRL.java
new file mode 100644
index 0000000000000000000000000000000000000000..f870ea5d001328699a0067a2f26d002eb6844bcb
--- /dev/null
+++ b/src/main/java/Enums/DirectionFRL.java
@@ -0,0 +1,18 @@
+package Enums;
+
+// TODO: Maybe actually replace these with a boolean and hard code...
+
+public enum DirectionFRL {
+ Forward(0),
+ Right(1),
+ Left(2);
+
+ private final int value;
+ private DirectionFRL(int value) {
+ this.value = value;
+ }
+
+ public int getValue() {
+ return value;
+ }
+}
diff --git a/src/main/java/Enums/DirectionNESW.java b/src/main/java/Enums/DirectionNESW.java
new file mode 100644
index 0000000000000000000000000000000000000000..5daa97ef051cb9e5ae688167f1a33c904b1208fb
--- /dev/null
+++ b/src/main/java/Enums/DirectionNESW.java
@@ -0,0 +1,19 @@
+package Enums;
+
+// TODO: Maybe actually replace these with a boolean and hard code...
+
+public enum DirectionNESW {
+ North(0),
+ East(1),
+ South(2),
+ West(3);
+
+ private final int value;
+ private DirectionNESW(int value) {
+ this.value = value;
+ }
+
+ public int getValue() {
+ return value;
+ }
+}
diff --git a/src/main/java/InitialGenerationCreators/Curl.java b/src/main/java/InitialGenerationCreators/Curl.java
new file mode 100644
index 0000000000000000000000000000000000000000..798da729bd724aa7f2c014c31872d598951be3e4
--- /dev/null
+++ b/src/main/java/InitialGenerationCreators/Curl.java
@@ -0,0 +1,108 @@
+package InitialGenerationCreators;
+
+import Enums.DirectionFRL;
+import Enums.DirectionNESW;
+import Interfaces.InitialGenerationCreator;
+import MainClasses.Candidate;
+
+public class Curl<T extends Enum<?>> implements InitialGenerationCreator {
+
+ Class<T> possibleDirections;
+
+ public Curl(Class<T> possibleDirections) {
+ this.possibleDirections = possibleDirections;
+ }
+
+ @Override
+ public Candidate[] initializeDirections(int populationSize, int[] isHydrophobic) {
+ Candidate[] population = new Candidate[populationSize];
+ int proteinLength = isHydrophobic.length;
+
+ int[] candidateDirections;
+ if (isFRLEncoding(possibleDirections) && populationSize > 0) {
+ candidateDirections = curlFRL(proteinLength);
+ } else {
+ candidateDirections = curlNESW(proteinLength);
+ }
+
+ for (int i = 0; i < populationSize; i++) {
+ population[i] = new Candidate(isHydrophobic, candidateDirections);
+ }
+
+ return population;
+ }
+
+ private int[] curlNESW(int proteinLength) {
+ int[] candidateDirections = new int[proteinLength];
+ int stepSize = 1;
+ int stepsLeft = 1;
+ boolean stepSizeChange = false; // To increase stepSize every second time
+ DirectionNESW dir = DirectionNESW.North;
+
+ for (int j = 0; j < proteinLength; j++) {
+ candidateDirections[j] = dir.getValue();
+ stepsLeft--;
+
+ if (stepsLeft == 0) {
+ if (stepSizeChange) {
+ stepSize++;
+ stepsLeft = stepSize;
+ stepSizeChange = false;
+ } else {
+ stepsLeft = stepSize;
+ stepSizeChange = true;
+ }
+
+ // Rotate direction
+ if (dir == DirectionNESW.North) {
+ dir = DirectionNESW.East;
+ } else if (dir == DirectionNESW.East) {
+ dir = DirectionNESW.South;
+ } else if (dir == DirectionNESW.South) {
+ dir = DirectionNESW.West;
+ } else {
+ dir = DirectionNESW.North;
+ }
+ }
+ }
+ return candidateDirections;
+ }
+
+ private int[] curlFRL(int proteinLength) {
+ int[] candidateDirections = new int[proteinLength];
+ candidateDirections[0] = DirectionFRL.Forward.getValue();
+
+ int stepSize = 0;
+ int stepsLeft = 0;
+ boolean stepSizeChange = false; // To increase stepSize every second time
+
+ for (int j = 1; j < proteinLength; j++) {
+ if (stepsLeft == 0) { // Turn
+ candidateDirections[j] = DirectionFRL.Right.getValue();
+
+ if (stepSizeChange) {
+ stepSize++;
+ stepSizeChange = false;
+ } else {
+ stepSizeChange = true;
+ }
+ stepsLeft = stepSize;
+
+ } else { // Straight
+ candidateDirections[j] = DirectionFRL.Forward.getValue();
+ stepsLeft--;
+ }
+ }
+ return candidateDirections;
+ }
+
+ private <T extends Enum<?>> boolean isFRLEncoding(Class<T> possibleDirections) {
+ T[] possibleDirectionsEnum = possibleDirections.getEnumConstants();
+ for (int i = 0; i < possibleDirectionsEnum.length; i++) {
+ if (possibleDirectionsEnum[i].equals(DirectionFRL.Forward)) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/src/main/java/InitialGenerationCreators/RandomDirection.java b/src/main/java/InitialGenerationCreators/RandomDirection.java
new file mode 100644
index 0000000000000000000000000000000000000000..20eafa287d56e30ffb6d4ebefb84c4bf305ebe60
--- /dev/null
+++ b/src/main/java/InitialGenerationCreators/RandomDirection.java
@@ -0,0 +1,38 @@
+package InitialGenerationCreators;
+
+import Enums.DirectionNESW;
+import Interfaces.InitialGenerationCreator;
+import MainClasses.Candidate;
+
+import java.util.Random;
+
+public class RandomDirection<T extends Enum<?>> implements InitialGenerationCreator {
+
+ Random rand;
+ Class<T> possibleDirections;
+
+ public RandomDirection(Random rand, Class<T> possibleDirections) {
+ this.rand = rand;
+ this.possibleDirections = possibleDirections;
+ }
+
+ @Override
+ public Candidate[] initializeDirections(int populationSize, int[] isHydrophobic) {
+ Candidate[] population = new Candidate[populationSize];
+ int proteinLength = isHydrophobic.length;
+
+ for (int i = 0; i < populationSize; i++) {
+ int[] candidateDirections = new int[proteinLength];
+ for (int j = 0; j < proteinLength; j++) {
+ candidateDirections[j] = this.randomDirection(this.possibleDirections);
+ }
+ population[i] = new Candidate(isHydrophobic, candidateDirections);
+ }
+
+ return population;
+ }
+
+ private int randomDirection(Class<T> dirEnum) {
+ return rand.nextInt(dirEnum.getEnumConstants().length);
+ }
+}
diff --git a/src/main/java/InitialGenerationCreators/StraightLine.java b/src/main/java/InitialGenerationCreators/StraightLine.java
new file mode 100644
index 0000000000000000000000000000000000000000..abdde5c504779dabe7488e4e63d44cd05c1efb1d
--- /dev/null
+++ b/src/main/java/InitialGenerationCreators/StraightLine.java
@@ -0,0 +1,30 @@
+package InitialGenerationCreators;
+
+import Enums.DirectionFRL;
+import Interfaces.InitialGenerationCreator;
+import MainClasses.Candidate;
+
+import java.util.Random;
+
+public class StraightLine implements InitialGenerationCreator {
+
+ public StraightLine() {
+ }
+
+ @Override
+ public Candidate[] initializeDirections(int populationSize, int[] isHydrophobic) {
+ Candidate[] population = new Candidate[populationSize];
+ int proteinLength = isHydrophobic.length;
+
+ int[] candidateDirections = new int[proteinLength];
+ for (int j = 0; j < proteinLength; j++) {
+ candidateDirections[j] = 0; // Default starting direction is set by Enum
+ }
+
+ for (int i = 0; i < populationSize; i++) {
+ population[i] = new Candidate(isHydrophobic, candidateDirections);
+ }
+
+ return population;
+ }
+}
diff --git a/src/main/java/Interfaces/Evaluater.java b/src/main/java/Interfaces/Evaluater.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e0557427375fab813758c6323b6988d46f550b2
--- /dev/null
+++ b/src/main/java/Interfaces/Evaluater.java
@@ -0,0 +1,4 @@
+package Interfaces;
+
+public interface Evaluater {
+}
diff --git a/src/main/java/Interfaces/InitialGenerationCreator.java b/src/main/java/Interfaces/InitialGenerationCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..182069c21397b50fb7d237f38b6280f592c9a2f2
--- /dev/null
+++ b/src/main/java/Interfaces/InitialGenerationCreator.java
@@ -0,0 +1,8 @@
+package Interfaces;
+
+import MainClasses.Candidate;
+
+public interface InitialGenerationCreator {
+
+ Candidate[] initializeDirections(int populationSize, int[] isHydrophobic);
+}
diff --git a/src/main/java/Interfaces/Mutator.java b/src/main/java/Interfaces/Mutator.java
new file mode 100644
index 0000000000000000000000000000000000000000..90e45beedd70f17ea1c4584b09a05215429b3c4c
--- /dev/null
+++ b/src/main/java/Interfaces/Mutator.java
@@ -0,0 +1,4 @@
+package Interfaces;
+
+public interface Mutator {
+}
diff --git a/src/main/java/Interfaces/Selector.java b/src/main/java/Interfaces/Selector.java
new file mode 100644
index 0000000000000000000000000000000000000000..123c19943335ea6a6a256bb16dd2f8f71d25be0b
--- /dev/null
+++ b/src/main/java/Interfaces/Selector.java
@@ -0,0 +1,4 @@
+package Interfaces;
+
+public interface Selector {
+}
diff --git a/src/main/java/Interfaces/Visualizer.java b/src/main/java/Interfaces/Visualizer.java
new file mode 100644
index 0000000000000000000000000000000000000000..f93e288b9162a71a72e181d32872202f994d8e78
--- /dev/null
+++ b/src/main/java/Interfaces/Visualizer.java
@@ -0,0 +1,4 @@
+package Interfaces;
+
+public interface Visualizer {
+}
diff --git a/src/main/java/Candidate.java b/src/main/java/MainClasses/Candidate.java
similarity index 99%
rename from src/main/java/Candidate.java
rename to src/main/java/MainClasses/Candidate.java
index 42fa4f206111725f140bca6e5855931161467b73..50e25e957ac8b980a50fb9c30041bfd502637397 100644
--- a/src/main/java/Candidate.java
+++ b/src/main/java/MainClasses/Candidate.java
@@ -1,3 +1,5 @@
+package MainClasses;
+
import java.util.ArrayList;
import java.util.Arrays;
diff --git a/src/main/java/Examples.java b/src/main/java/MainClasses/Examples.java
similarity index 97%
rename from src/main/java/Examples.java
rename to src/main/java/MainClasses/Examples.java
index ee4593759b1cbb4ac88548a4aa357c527d11ae9d..dc829b3303b8fa9277ed668ea607f949df644bbb 100644
--- a/src/main/java/Examples.java
+++ b/src/main/java/MainClasses/Examples.java
@@ -1,4 +1,4 @@
-
+package MainClasses;
// benchmark sequences for the 2d HP model
// 0 = hydrophil, "white"
// 1 = hydrophob, "black"
diff --git a/src/main/java/GeneticAlgorithm.java b/src/main/java/MainClasses/GeneticAlgorithm.java
similarity index 92%
rename from src/main/java/GeneticAlgorithm.java
rename to src/main/java/MainClasses/GeneticAlgorithm.java
index 727d69fa8cfafc1048f478b667a60b4538111731..8b6354fb3e357987a2ac058fd620b65d38c4727f 100644
--- a/src/main/java/GeneticAlgorithm.java
+++ b/src/main/java/MainClasses/GeneticAlgorithm.java
@@ -1,3 +1,11 @@
+package MainClasses;
+
+import Enums.DirectionNESW;
+import InitialGenerationCreators.Curl;
+import InitialGenerationCreators.RandomDirection;
+import InitialGenerationCreators.StraightLine;
+import Interfaces.InitialGenerationCreator;
+
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
@@ -35,11 +43,17 @@ public class GeneticAlgorithm {
tournament
}
+ InitialGenerationCreator initialGenCreator;
+
Selection selectionVariant;
int k; // Number of selected Candidates to face off in a tournament selection
// Initialize with protein
public GeneticAlgorithm (Properties properties, int[] protein) {
+// this.initialGenCreator = new RandomDirection(this.rand, DirectionNESW.class);
+// this.initialGenCreator = new StraightLine();
+ this.initialGenCreator = new Curl(DirectionNESW.class);
+
this.properties = properties;
this.isHydrophobic = protein;
initializeProperties();
@@ -53,7 +67,7 @@ public class GeneticAlgorithm {
e.printStackTrace();
}
- this.population = generateInitalPopulation();
+ this.population = this.initialGenCreator.initializeDirections(this.populationSize, this.isHydrophobic);
this.totalFitness = 0;
this.fitness = new double[populationSize];
this.overallBestFitness = 0;
@@ -87,21 +101,6 @@ public class GeneticAlgorithm {
this.pdraw = new ProteinDrawer(properties.getProperty("imageSequencePath"));
}
- // Generate initial population
- private Candidate[] generateInitalPopulation() {
- Candidate[] population = new Candidate[populationSize];
-
- for (int i = 0; i < populationSize; i++) {
- int[] canidateDirections = new int[isHydrophobic.length];
- for (int j = 0; j < isHydrophobic.length; j++) {
- canidateDirections[j] = rand.nextInt(4);
- }
- population[i] = new Candidate(isHydrophobic, canidateDirections);
- }
-
- return population;
- }
-
public void simulateGenerations() {
for (int gen = 0; gen < totalGenerations-1; gen++) {
evaluateGeneration(gen);
@@ -140,7 +139,7 @@ public class GeneticAlgorithm {
pdraw.drawProteinToFile(population[bestIndex].getVertexList(), population[bestIndex].calculateFitness(true), gen);
// Save the overall best
- if (bestFitness > overallBestFitness) {
+ if (bestFitness >= overallBestFitness) {
overallBestFitness = bestFitness;
overallBest = new Candidate(this.isHydrophobic, population[bestIndex].getOutgoing());
}
diff --git a/src/main/java/JpegImagesToMovie.java b/src/main/java/MainClasses/JpegImagesToMovie.java
similarity index 97%
rename from src/main/java/JpegImagesToMovie.java
rename to src/main/java/MainClasses/JpegImagesToMovie.java
index 992ef43732f4d6bc3f03c6c4f3b8bfb8464e1717..12ea63cbfc1553b6f6e91bf260c6533e6702c16c 100644
--- a/src/main/java/JpegImagesToMovie.java
+++ b/src/main/java/MainClasses/JpegImagesToMovie.java
@@ -1,5 +1,5 @@
-/*
- * @(#)JpegImagesToMovie.java 1.3 01/03/13
+package MainClasses;/*
+ * @(#)MainClasses.JpegImagesToMovie.java 1.3 01/03/13
* Copyright (c) 1999-2001 Sun Microsystems, Inc. All Rights Reserved.
* Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
* modify and redistribute this software in source and binary code form,
@@ -324,7 +324,7 @@ public class JpegImagesToMovie implements ControllerListener, DataSinkListener {
System.exit(0);
}
- JpegImagesToMovie imageToMovie = new JpegImagesToMovie();
+ MainClasses.JpegImagesToMovie imageToMovie = new MainClasses.JpegImagesToMovie();
imageToMovie.doIt(width, height, frameRate, inputFiles, oml);
System.exit(0);
@@ -332,7 +332,7 @@ public class JpegImagesToMovie implements ControllerListener, DataSinkListener {
static void prUsage() {
System.err
- .println("Usage: java JpegImagesToMovie -w <width> -h <height> -f <frame rate> -o <output URL> <input JPEG file 1> <input JPEG file 2> ...");
+ .println("Usage: java MainClasses.JpegImagesToMovie -w <width> -h <height> -f <frame rate> -o <output URL> <input JPEG file 1> <input JPEG file 2> ...");
System.exit(-1);
}
diff --git a/src/main/java/Main.java b/src/main/java/MainClasses/Main.java
similarity index 92%
rename from src/main/java/Main.java
rename to src/main/java/MainClasses/Main.java
index 8f8cc426e9830b06d488b036ba671b6883b9fce6..ae3c48cd74f46946dd1c7d634c9b7715bd431c0d 100644
--- a/src/main/java/Main.java
+++ b/src/main/java/MainClasses/Main.java
@@ -1,11 +1,9 @@
+package MainClasses;
+
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
-import java.lang.reflect.Array;
-import java.util.ArrayList;
-import java.util.List;
import java.util.Properties;
-import java.util.Random;
public class Main {
@@ -30,7 +28,7 @@ public class Main {
e.printStackTrace();
}
-// ProteinDrawer pdraw = new ProteinDrawer("./visualization/individual/", "image.jpg");
+// MainClasses.ProteinDrawer pdraw = new MainClasses.ProteinDrawer("./visualization/individual/", "image.jpg");
//
//
// int[] isHydrophobic = {0, 0, 0, 1, 0, 1, 1, 0, 0}; // 0 = no | 1 = yes
diff --git a/src/main/java/ProteinDrawer.java b/src/main/java/MainClasses/ProteinDrawer.java
similarity index 99%
rename from src/main/java/ProteinDrawer.java
rename to src/main/java/MainClasses/ProteinDrawer.java
index 0dd4b71b30fda3b2a21418e699f786de168b40b7..5efc888e08dbc368481ac9c35be5ccb636d5ac73 100644
--- a/src/main/java/ProteinDrawer.java
+++ b/src/main/java/MainClasses/ProteinDrawer.java
@@ -1,3 +1,5 @@
+package MainClasses;
+
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
diff --git a/src/main/java/Vertex.java b/src/main/java/MainClasses/Vertex.java
similarity index 97%
rename from src/main/java/Vertex.java
rename to src/main/java/MainClasses/Vertex.java
index be0ef1cd967d6c5e18c6398ea41a0bb21c8f5eeb..5c62cd3688e3ae915ed7c73f39c8e6237b3c9d8a 100644
--- a/src/main/java/Vertex.java
+++ b/src/main/java/MainClasses/Vertex.java
@@ -1,3 +1,5 @@
+package MainClasses;
+
// Helper class representing a single amino acid
class Vertex {
int x;
diff --git a/src/main/java/VideoCreator.java b/src/main/java/MainClasses/VideoCreator.java
similarity index 88%
rename from src/main/java/VideoCreator.java
rename to src/main/java/MainClasses/VideoCreator.java
index 2df6611150b8318a2b18a622ea94248821610d2f..4c7c81fc21ca298704e6d728e72fee2a20ad7970 100644
--- a/src/main/java/VideoCreator.java
+++ b/src/main/java/MainClasses/VideoCreator.java
@@ -1,5 +1,6 @@
+package MainClasses;
+
import java.awt.Graphics2D;
-import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FilenameFilter;
@@ -12,6 +13,7 @@ import javax.media.MediaLocator;
public class VideoCreator{
+ private static final int MAXIMUM_SIZE = 3000;
public static File dir = new File("./visualization/series"); // Default
public static final String[] extensions = new String[]{"jpg", "png"};
public static final FilenameFilter imageFilter = new FilenameFilter() {
@@ -32,8 +34,8 @@ public class VideoCreator{
if (dir.isDirectory()) {
// reads input images and determines maximum required size
- int maxHeight = ProteinDrawer.maxWidth;
- int maxWidth = ProteinDrawer.maxHeight;
+ int maxHeight = ProteinDrawer.maxHeight;
+ int maxWidth = ProteinDrawer.maxWidth;
if (maxHeight <= 0 || maxWidth <= 0) {
int counter = 1;
@@ -48,6 +50,14 @@ public class VideoCreator{
}
}
+ // Needed because video is not playable with bigger sizes, mostly a concern for straight line initialization
+ if (maxWidth > MAXIMUM_SIZE) {
+ maxWidth = MAXIMUM_SIZE;
+ }
+ if (maxHeight > MAXIMUM_SIZE) {
+ maxHeight = MAXIMUM_SIZE;
+ }
+
widthHeight[0] = maxWidth;
widthHeight[1] = maxHeight;
@@ -74,7 +84,7 @@ public class VideoCreator{
return widthHeight;
}
- // Main function
+ // MainClasses.Main function
public static void createVideo(Properties properties) throws IOException {
String imagesPath = properties.getProperty("imageSequencePath");
String videoPathAndFile = properties.getProperty("videoPathAndFile");
diff --git a/src/main/resources/genetic.properties b/src/main/resources/genetic.properties
index 52e499bf9fd8712d841fb7b3e03e7680f89f3e75..bc334681e2a76dd86cbedd74e63e4dbb5b6d3e38 100644
--- a/src/main/resources/genetic.properties
+++ b/src/main/resources/genetic.properties
@@ -1,7 +1,7 @@
logfilePath = log.txt
-populationSize = 300
+populationSize = 10
# Do NOT go OVER 1_000_000 generations, as the filenames don't play nice then
-noGenerations = 1000
+noGenerations = 10
# proportional OR tournament
selection = proportional
# Number of tournament participants
@@ -12,11 +12,16 @@ mutationChance = 1.0
# Decline in mutation probability with generations -> ex with 0.05: 2nd 0.95, 3rd 0.9025, 4th 0.857
mutationDecline = 0.001
mutationAttemptsPerCanidate = 1
-crossoverChance = 0.2
-crossoverDecline = 0.01
+crossoverChance = 0.6
+crossoverDecline = 0.005
# For video
imageSequencePath = ./visualization/series
videoPathAndFile = ./visualization/video.mp4
# ms between images
-imgInterval = 100
\ No newline at end of file
+imgInterval = 100
+
+
+# TODO:
+createVideo = true
+initializationMethod = curl, straight, random
\ No newline at end of file