diff --git a/src/main/java/MainClasses/Config.java b/src/main/java/MainClasses/Config.java index 1bc7151f92034a7b883d597fd5a36d42383bb34b..44c55236bd6fc7b1bd01885f319c819fa5336960 100644 --- a/src/main/java/MainClasses/Config.java +++ b/src/main/java/MainClasses/Config.java @@ -13,59 +13,59 @@ import java.util.Properties; public class Config { - String propertyPath; - Properties properties; - - static String ENCODING_VARIANT; - static int SEED; - - - static int POPULATION_SIZE; - static int TOTAL_GENERATIONS; - static InitializationMethods INITIALIZATION_METHOD; - static SelectionMethods SELECTION_METHOD; - static int K; // Number of selected Candidates to face off in a tournament selection - static MutatorMethods[] MUTATOR_METHODS; - static int POINTS_PER_BOND; // Points per hydrophobic bond, default Evaluator will work the same with any value - - static int MUTATION_ATTEMPTS_PER_CANDIDATE; - static double MUTATION_CHANCE; - static double MUTATION_MULTIPLIER; - static double MUTATION_MINIMAL_CHANCE; // -> 0.01% is not worth mutating for - static int CROSSOVER_ATTEMPTS_PER_CANDIDATE; - static double CROSSOVER_CHANCE; - static double CROSSOVER_MINIMAL_CHANCE; // -> 0.01% is not worth mutating for - static double CROSSOVER_MULTIPLIER; - - static String LOGFILE; - static VisualizerMethods[] VISUALIZERS; - static String IMAGE_SEQUENCE_PATH; - static String VIDEO_PATH_AND_FILE; - static int IMAGE_FPS; - static int IMAGES_TO_FPS_INCREASE; - static int IMAGE_FPS_MAX; - static boolean ZOOM; + private String propertyPath; + private Properties properties; + + private String encodingVariant; + private int seed; + + + private int populationSize; + private int totalGenerations; + private InitializationMethods initializationMethod; + private SelectionMethods selectionMethod; + private int k; // Number of selected Candidates to face off in a tournament selection + private MutatorMethods[] mutatorMethods; + private int pointsPerBond; // Points per hydrophobic bond, default Evaluator will work the same with any value + + private int mutationAttemptsPerCandidate; + private double mutationChance; + private double mutationMultiplier; + private double mutationMinimalChance; // -> 0.01% is not worth mutating for + private int crossoverAttemptsPerCandidate; + private double crossoverChance; + private double crossoverMinimalChance; // -> 0.01% is not worth mutating for + private double crossoverMultiplier; + + private String logfile; + private VisualizerMethods[] visualizers; + private String imageSequencePath; + private String videoPathAndFile; + private int imageFps; + private int imagesToFpsIncrease; + private int imageFpsMax; + private boolean zoom; // For images - public static final Font font = new Font("Sans-Serif", Font.PLAIN, 15); - public static final Color imageBackground = new Color(255, 255, 255); - public static final Color imageConnection = new Color(0, 0, 0); - public static final Color imageOutline = new Color(0, 0, 0); - public static final Color imageHydrophobic = new Color(205, 0, 0); - public static final Color imageHydrophilic = new Color(0, 0, 255); - public static final Color imageMixed = new Color(205, 0, 205); - public static final Color imageAminoText = new Color(0, 190, 190); - public static final Color imageText = new Color(0,0,0); + private final Font font = new Font("Sans-Serif", Font.PLAIN, 15); + private final Color imageBackground = new Color(255, 255, 255); + private final Color imageConnection = new Color(0, 0, 0); + private final Color imageOutline = new Color(0, 0, 0); + private final Color imageHydrophobic = new Color(205, 0, 0); + private final Color imageHydrophilic = new Color(0, 0, 255); + private final Color imageMixed = new Color(205, 0, 205); + private final Color imageAminoText = new Color(0, 190, 190); + private final Color imageText = new Color(0,0,0); // For console output - public static final String consoleEmpty = " "; - public static final String consoleHydrophobic = "(o)"; - public static final String consoleHydrophilic = "(i)"; - public static final String consoleHydrophobicMulti = "{o}"; - public static final String consoleHydrophilicMulti = "{i}"; - public static final String consoleMixed = "{z}"; - public static final String consoleConnectionVertical = " | "; - public static final String consoleConnectionHorizontal = "---"; + private final String consoleEmpty = " "; + private final String consoleHydrophobic = "(o)"; + private final String consoleHydrophilic = "(i)"; + private final String consoleHydrophobicMulti = "{o}"; + private final String consoleHydrophilicMulti = "{i}"; + private final String consoleMixed = "{z}"; + private final String consoleConnectionVertical = " | "; + private final String consoleConnectionHorizontal = "---"; public Config(String propertyPath) { this.propertyPath = propertyPath; @@ -90,92 +90,259 @@ public class Config { private void initializeProperties() { // Basic Initialization settings - ENCODING_VARIANT = this.properties.getProperty("encodingVariant"); - SEED = Integer.parseInt(this.properties.getProperty("seed")); + encodingVariant = this.properties.getProperty("encodingVariant"); + seed = Integer.parseInt(this.properties.getProperty("seed")); // Algorithm settings - POPULATION_SIZE = Integer.parseInt(this.properties.getProperty("populationSize")); - TOTAL_GENERATIONS = Integer.parseInt(this.properties.getProperty("noGenerations")); + populationSize = Integer.parseInt(this.properties.getProperty("populationSize")); + totalGenerations = Integer.parseInt(this.properties.getProperty("noGenerations")); switch (this.properties.getProperty("initializationMethod")) { case "curl": - INITIALIZATION_METHOD = InitializationMethods.Curl; + initializationMethod = InitializationMethods.Curl; break; case "straight": - INITIALIZATION_METHOD = InitializationMethods.Straight; + initializationMethod = InitializationMethods.Straight; break; case "random": - INITIALIZATION_METHOD = InitializationMethods.Random; + initializationMethod = InitializationMethods.Random; break; } switch (this.properties.getProperty("selectionMethod")) { case "proportional": - SELECTION_METHOD = SelectionMethods.Proportional; + selectionMethod = SelectionMethods.Proportional; break; case "tournament": - SELECTION_METHOD = SelectionMethods.Tournament; + selectionMethod = SelectionMethods.Tournament; break; case "onlybest": - SELECTION_METHOD = SelectionMethods.OnlyBest; + selectionMethod = SelectionMethods.OnlyBest; break; } - K = Integer.parseInt(this.properties.getProperty("k")); + k = Integer.parseInt(this.properties.getProperty("k")); String[] mutatorsToUse = this.properties.getProperty("mutatorMethods").split(","); - MUTATOR_METHODS = new MutatorMethods[mutatorsToUse.length]; + mutatorMethods = new MutatorMethods[mutatorsToUse.length]; for (int i = 0; i < mutatorsToUse.length; i++) { if (mutatorsToUse[i].equals("singlePoint")) { - MUTATOR_METHODS[i] = MutatorMethods.SinglePoint; + mutatorMethods[i] = MutatorMethods.SinglePoint; } else if (mutatorsToUse[i].equals("crossover")) { - MUTATOR_METHODS[i] = MutatorMethods.Crossover; + mutatorMethods[i] = MutatorMethods.Crossover; } } - POINTS_PER_BOND = Integer.parseInt(this.properties.getProperty("pointsPerBond")); + pointsPerBond = Integer.parseInt(this.properties.getProperty("pointsPerBond")); // Mutation settings - MUTATION_ATTEMPTS_PER_CANDIDATE = Integer.parseInt(this.properties.getProperty("mutationAttemptsPerCandidate")); - MUTATION_CHANCE = Double.parseDouble(this.properties.getProperty("mutationChance")); - MUTATION_MINIMAL_CHANCE = Double.parseDouble(this.properties.getProperty("mutationMinimalChance")); - MUTATION_MULTIPLIER = Double.parseDouble(this.properties.getProperty("mutationMultiplier")); - CROSSOVER_ATTEMPTS_PER_CANDIDATE = Integer.parseInt(this.properties.getProperty("crossoverAttemptsPerCandidate")); - CROSSOVER_CHANCE = Double.parseDouble(this.properties.getProperty("crossoverChance")); - CROSSOVER_MINIMAL_CHANCE = Double.parseDouble(this.properties.getProperty("crossoverMinimalChance")); - CROSSOVER_MULTIPLIER = Double.parseDouble(this.properties.getProperty("crossoverMultiplier")); - + mutationAttemptsPerCandidate = Integer.parseInt(this.properties.getProperty("mutationAttemptsPerCandidate")); + mutationChance = Double.parseDouble(this.properties.getProperty("mutationChance")); + mutationMinimalChance = Double.parseDouble(this.properties.getProperty("mutationMinimalChance")); + mutationMultiplier = Double.parseDouble(this.properties.getProperty("mutationMultiplier")); + crossoverAttemptsPerCandidate = Integer.parseInt(this.properties.getProperty("crossoverAttemptsPerCandidate")); + crossoverChance = Double.parseDouble(this.properties.getProperty("crossoverChance")); + crossoverMinimalChance = Double.parseDouble(this.properties.getProperty("crossoverMinimalChance")); + crossoverMultiplier = Double.parseDouble(this.properties.getProperty("crossoverMultiplier")); // Output settings - LOGFILE = this.properties.getProperty("logfilePath"); + logfile = this.properties.getProperty("logfilePath"); String[] visualizersToUse = this.properties.getProperty("visualizerType").split(","); - VISUALIZERS = new VisualizerMethods[visualizersToUse.length]; + visualizers = new VisualizerMethods[visualizersToUse.length]; for (int i = 0; i < visualizersToUse.length; i++) { switch (visualizersToUse[i]) { case "console": - VISUALIZERS[i] = VisualizerMethods.Console; + visualizers[i] = VisualizerMethods.Console; break; case "image": - VISUALIZERS[i] = VisualizerMethods.Image; + visualizers[i] = VisualizerMethods.Image; break; case "video": - VISUALIZERS[i] = VisualizerMethods.Video; + visualizers[i] = VisualizerMethods.Video; break; } } - IMAGE_SEQUENCE_PATH = this.properties.getProperty("imageSequencePath"); - VIDEO_PATH_AND_FILE = this.properties.getProperty("videoPathAndFile"); - IMAGE_FPS = Integer.parseInt(this.properties.getProperty("imgFps")); - IMAGES_TO_FPS_INCREASE = Integer.parseInt(this.properties.getProperty("imagesToFpsIncrease")); - IMAGE_FPS_MAX = Integer.parseInt(this.properties.getProperty("imgFpsMax")); - ZOOM = this.properties.getProperty("zoom").equals("true"); + imageSequencePath = this.properties.getProperty("imageSequencePath"); + videoPathAndFile = this.properties.getProperty("videoPathAndFile"); + imageFps = Integer.parseInt(this.properties.getProperty("imgFps")); + imagesToFpsIncrease = Integer.parseInt(this.properties.getProperty("imagesToFpsIncrease")); + imageFpsMax = Integer.parseInt(this.properties.getProperty("imgFpsMax")); + zoom = this.properties.getProperty("zoom").equals("true"); } public Properties getProperties() { return this.properties; } + public String getEncodingVariant() { + return encodingVariant; + } + + public int getSeed() { + return seed; + } + + public int getPopulationSize() { + return populationSize; + } + + public int getTotalGenerations() { + return totalGenerations; + } + + public InitializationMethods getInitializationMethod() { + return initializationMethod; + } + + public SelectionMethods getSelectionMethod() { + return selectionMethod; + } + + public int getK() { + return k; + } + + public MutatorMethods[] getMutatorMethods() { + return mutatorMethods; + } + + public int getPointsPerBond() { + return pointsPerBond; + } + + public int getMutationAttemptsPerCandidate() { + return mutationAttemptsPerCandidate; + } + + public double getMutationChance() { + return mutationChance; + } + + public double getMutationMultiplier() { + return mutationMultiplier; + } + + public double getMutationMinimalChance() { + return mutationMinimalChance; + } + + public int getCrossoverAttemptsPerCandidate() { + return crossoverAttemptsPerCandidate; + } + + public double getCrossoverChance() { + return crossoverChance; + } + + public double getCrossoverMinimalChance() { + return crossoverMinimalChance; + } + + public double getCrossoverMultiplier() { + return crossoverMultiplier; + } + + public String getLogfile() { + return logfile; + } + + public VisualizerMethods[] getVisualizers() { + return visualizers; + } + + public String getImageSequencePath() { + return imageSequencePath; + } + + public String getVideoPathAndFile() { + return videoPathAndFile; + } + + public int getImageFps() { + return imageFps; + } + + public int getImagesToFpsIncrease() { + return imagesToFpsIncrease; + } + + public int getImageFpsMax() { + return imageFpsMax; + } + + public boolean isZoom() { + return zoom; + } + + public Font getFont() { + return font; + } + + public Color getImageBackground() { + return imageBackground; + } + + public Color getImageConnection() { + return imageConnection; + } + + public Color getImageOutline() { + return imageOutline; + } + + public Color getImageHydrophobic() { + return imageHydrophobic; + } + + public Color getImageHydrophilic() { + return imageHydrophilic; + } + + public Color getImageMixed() { + return imageMixed; + } + + public Color getImageAminoText() { + return imageAminoText; + } + + public Color getImageText() { + return imageText; + } + + public String getConsoleEmpty() { + return consoleEmpty; + } + + public String getConsoleHydrophobic() { + return consoleHydrophobic; + } + + public String getConsoleHydrophilic() { + return consoleHydrophilic; + } + + public String getConsoleHydrophobicMulti() { + return consoleHydrophobicMulti; + } + + public String getConsoleHydrophilicMulti() { + return consoleHydrophilicMulti; + } + + public String getConsoleMixed() { + return consoleMixed; + } + + public String getConsoleConnectionVertical() { + return consoleConnectionVertical; + } + + public String getConsoleConnectionHorizontal() { + return consoleConnectionHorizontal; + } + } diff --git a/src/main/java/MainClasses/GeneticAlgorithm.java b/src/main/java/MainClasses/GeneticAlgorithm.java index bc063fdf5c4047765e900146e20840f1a47bcff1..f4b9254e3d5a725e6861eb3f42c84fc6fb17f5b1 100644 --- a/src/main/java/MainClasses/GeneticAlgorithm.java +++ b/src/main/java/MainClasses/GeneticAlgorithm.java @@ -23,6 +23,8 @@ import java.util.Random; public class GeneticAlgorithm { Random rand; + Config config; + int[] isHydrophobic; Candidate[] population; @@ -39,77 +41,78 @@ public class GeneticAlgorithm { Visualizer[] visualizers; // Initialize with protein - public GeneticAlgorithm (int[] protein) { + public GeneticAlgorithm (int[] protein, Config config) { this.isHydrophobic = protein; + this.config = config; this.initializeSettings(); this.clearLog(); - this.population = this.initialGenCreator.initializeDirections(Config.POPULATION_SIZE, this.isHydrophobic.length); + this.population = this.initialGenCreator.initializeDirections(config.getPopulationSize(), this.isHydrophobic.length); this.totalFitness = 0; - this.fitness = new double[Config.POPULATION_SIZE]; + this.fitness = new double[config.getPopulationSize()]; this.overallBestFitness = 0; } private void initializeSettings() { - if (Config.SEED != -1) { - this.rand = new Random(Config.SEED); + if (config.getSeed() != -1) { + this.rand = new Random(config.getSeed()); } else { this.rand = new Random(); } // Settings that are dependant on encoding - if (Config.ENCODING_VARIANT.equals("NESW")) { + if (config.getEncodingVariant().equals("NESW")) { int nullCount = 0; - for (int i = 0; i < Config.VISUALIZERS.length; i++) { - if (!Config.VISUALIZERS[i].equals(VisualizerMethods.Console) - && !Config.VISUALIZERS[i].equals(VisualizerMethods.Image)) { + for (int i = 0; i < config.getVisualizers().length; i++) { + if (!config.getVisualizers()[i].equals(VisualizerMethods.Console) + && !config.getVisualizers()[i].equals(VisualizerMethods.Image)) { nullCount++; } } - this.visualizers = new Visualizer[Config.VISUALIZERS.length - nullCount]; + this.visualizers = new Visualizer[config.getVisualizers().length - nullCount]; int j = 0; - for (VisualizerMethods vm : Config.VISUALIZERS) { + for (VisualizerMethods vm : config.getVisualizers()) { if (vm.equals(VisualizerMethods.Console)) { - this.visualizers[j] = new VisualizerNESWtoConsole(isHydrophobic); + this.visualizers[j] = new VisualizerNESWtoConsole(isHydrophobic, config); j++; } else if (vm.equals(VisualizerMethods.Image)) { - this.visualizers[j] = new VisualizerNESWtoFile(Config.IMAGE_SEQUENCE_PATH,isHydrophobic); + this.visualizers[j] = new VisualizerNESWtoFile(isHydrophobic, config); j++; } } - if (Config.INITIALIZATION_METHOD.equals(InitializationMethods.Curl)) { + if (config.getInitializationMethod().equals(InitializationMethods.Curl)) { this.initialGenCreator = new Curl<>(DirectionNESW.class); - } else if (Config.INITIALIZATION_METHOD.equals(InitializationMethods.Straight)) { + } else if (config.getInitializationMethod().equals(InitializationMethods.Straight)) { this.initialGenCreator = new StraightLine(); - } else if (Config.INITIALIZATION_METHOD.equals(InitializationMethods.Random)) { + } else if (config.getInitializationMethod().equals(InitializationMethods.Random)) { this.initialGenCreator = new RandomDirection<>(DirectionNESW.class, this.rand); } - this.mutators = new Mutator[Config.MUTATOR_METHODS.length]; - for (int i = 0; i < Config.MUTATOR_METHODS.length; i++) { - if (Config.MUTATOR_METHODS[i].equals(MutatorMethods.SinglePoint)) { + this.mutators = new Mutator[config.getMutatorMethods().length]; + for (int i = 0; i < config.getMutatorMethods().length; i++) { + if (config.getMutatorMethods()[i].equals(MutatorMethods.SinglePoint)) { this.mutators[i] = new SinglePoint<>(DirectionNESW.class, this.rand, - Config.MUTATION_ATTEMPTS_PER_CANDIDATE, Config.MUTATION_CHANCE, Config.MUTATION_MINIMAL_CHANCE, Config.MUTATION_MULTIPLIER); + config.getMutationAttemptsPerCandidate(), config.getMutationChance(), config.getMutationMinimalChance(), config.getMutationMultiplier()); - } else if (Config.MUTATOR_METHODS[i].equals(MutatorMethods.Crossover)) { + } else if (config.getMutatorMethods()[i].equals(MutatorMethods.Crossover)) { this.mutators[i] = new Crossover<>(DirectionNESW.class, this.rand, - Config.CROSSOVER_ATTEMPTS_PER_CANDIDATE, Config.CROSSOVER_CHANCE, Config.MUTATION_MINIMAL_CHANCE, Config.CROSSOVER_MULTIPLIER); + config.getCrossoverAttemptsPerCandidate(), config.getCrossoverChance(), config.getMutationMinimalChance(), config.getCrossoverMultiplier()); } } - this.evaluator = new EvaluatorNESW(Config.POINTS_PER_BOND, isHydrophobic); + this.evaluator = new EvaluatorNESW(config.getPointsPerBond(), isHydrophobic); } else { // TODO: initialization for FRL settings } - if (Config.SELECTION_METHOD.equals(SelectionMethods.Proportional)) { + if (config.getSelectionMethod().equals(SelectionMethods.Proportional)) { this.selector = new FitnessProportional(this.rand, this.isHydrophobic); - } else if (Config.SELECTION_METHOD.equals(SelectionMethods.Tournament)) { - this.selector = new Tournament(this.rand, this.isHydrophobic, Config.K); - } else if (Config.SELECTION_METHOD.equals(SelectionMethods.OnlyBest)) { + } else if (config.getSelectionMethod().equals(SelectionMethods.Tournament)) { + this.selector = new Tournament(this.rand, this.isHydrophobic, config.getK()); + } else if (config.getSelectionMethod().equals(SelectionMethods.OnlyBest)) { this.selector = new OnlyBest(this.isHydrophobic); } } @@ -117,7 +120,7 @@ public class GeneticAlgorithm { private void clearLog() { String content = "Generation\tAverage Fitness\tBest Fitness\tOverall Best Fitness\tBonds\tOverlaps\n"; try { - Files.write(Paths.get(Config.LOGFILE), content.getBytes()); + Files.write(Paths.get(config.getLogfile()), content.getBytes()); } catch (IOException e) { e.printStackTrace(); @@ -125,7 +128,7 @@ public class GeneticAlgorithm { } public void simulateGenerations() { - for (int gen = 0; gen < Config.TOTAL_GENERATIONS-1; gen++) { + for (int gen = 0; gen < config.getTotalGenerations()-1; gen++) { this.evaluateGeneration(gen); this.population = this.selector.selectNewPopulation(this.population, this.fitness, this.totalFitness); @@ -135,7 +138,7 @@ public class GeneticAlgorithm { System.out.println(); } - evaluateGeneration(Config.TOTAL_GENERATIONS-1); + evaluateGeneration(config.getTotalGenerations()-1); } private int evaluateGeneration(int gen) { @@ -145,7 +148,7 @@ public class GeneticAlgorithm { double bestFitness = 0; int bestIndex = 0; this.totalFitness = 0; - for (int i = 0; i < Config.POPULATION_SIZE; i++) { + for (int i = 0; i < config.getPopulationSize(); i++) { this.fitness[i] = this.evaluator.evaluateFitness(this.population[i]); this.totalFitness += this.fitness[i]; @@ -171,7 +174,7 @@ public class GeneticAlgorithm { this.overallBest = new Candidate(this.population[bestIndex].getFolding()); } - double averageFitness = this.totalFitness / Config.POPULATION_SIZE; + double averageFitness = this.totalFitness / config.getPopulationSize(); String log = String.format("%d\t%.4f\t%.4f\t%.4f\t %d\t%d\n", gen, averageFitness, bestFitness, this.evaluator.evaluateFitness(overallBest), @@ -179,7 +182,7 @@ public class GeneticAlgorithm { -1); try { - Files.write(Paths.get(Config.LOGFILE), log.getBytes(), StandardOpenOption.APPEND); + Files.write(Paths.get(config.getLogfile()), log.getBytes(), StandardOpenOption.APPEND); } catch (IOException e) { e.printStackTrace(); diff --git a/src/main/java/MainClasses/Main.java b/src/main/java/MainClasses/Main.java index 5968b43c114f6c8e251771c77af3ea45afe86320..072c9d98fe724d1186b4d0832715f7b7c0fdd97e 100644 --- a/src/main/java/MainClasses/Main.java +++ b/src/main/java/MainClasses/Main.java @@ -13,16 +13,16 @@ public class Main { Config config = new Config(propertyPath); int[] protein = Examples.convertStringToIntArray(Examples.SEQ36); - GeneticAlgorithm ga = new GeneticAlgorithm(protein); + GeneticAlgorithm ga = new GeneticAlgorithm(protein, config); ga.simulateGenerations(); // Create a new video if possible and desired - boolean imagesRefreshed = Arrays.asList(Config.VISUALIZERS).contains(VisualizerMethods.Image); - boolean videoEnabled = Arrays.asList(Config.VISUALIZERS).contains(VisualizerMethods.Video); + boolean imagesRefreshed = Arrays.asList(config.getVisualizers()).contains(VisualizerMethods.Image); + boolean videoEnabled = Arrays.asList(config.getVisualizers()).contains(VisualizerMethods.Video); if (imagesRefreshed && videoEnabled){ - VideoCreator.createVideo(Config.IMAGE_SEQUENCE_PATH, Config.VIDEO_PATH_AND_FILE, - Config.IMAGE_FPS, Config.IMAGES_TO_FPS_INCREASE, Config.IMAGE_FPS_MAX, - ga.getMaxH(), ga.getMaxW(), Config.ZOOM); + VideoCreator.createVideo(config.getImageSequencePath(), config.getVideoPathAndFile(), + config.getImageFps(), config.getImagesToFpsIncrease(), config.getImageFpsMax(), + ga.getMaxH(), ga.getMaxW(), config.isZoom()); } } } diff --git a/src/main/java/Visualization/VideoCreator.java b/src/main/java/Visualization/VideoCreator.java index 24c83611d5c10301fcb1cb2f05f92365a2a98558..6f16ce4eb2ea6ac4b4aaea90453001a4385f3a20 100644 --- a/src/main/java/Visualization/VideoCreator.java +++ b/src/main/java/Visualization/VideoCreator.java @@ -100,8 +100,9 @@ public class VideoCreator{ // draws input image to the top left corner Graphics2D g2d = outputImage.createGraphics(); - g2d.setColor(Config.imageBackground); - g2d.fillRect(0,0, maxWidth, maxHeight); + //TODO The following two lines should be unnecessary + //g2d.setColor(Config.imageBackground); + //g2d.fillRect(0,0, maxWidth, maxHeight); g2d.drawImage(inputImage, 0, 0, inputImage.getWidth(), inputImage.getHeight(), null); g2d.dispose(); @@ -162,8 +163,9 @@ public class VideoCreator{ // draws input image to the top left corner Graphics2D g2d = outputImage.createGraphics(); - g2d.setColor(Config.imageBackground); - g2d.fillRect(0,0, maxWidthAfterIndex[0], maxHeightAfterIndex[0]); + //TODO The following two lines should be unnecessary + //g2d.setColor(Config.imageBackground); + //g2d.fillRect(0,0, maxWidthAfterIndex[0], maxHeightAfterIndex[0]); int newHeight = 0; int newWidth = 0; diff --git a/src/main/java/Visualization/Visualizers/VisualizerNESWtoConsole.java b/src/main/java/Visualization/Visualizers/VisualizerNESWtoConsole.java index fa9de950167aaae715b6373085426012e4156490..b897275cde2601f85ab8cac6e12da9940ffbee39 100644 --- a/src/main/java/Visualization/Visualizers/VisualizerNESWtoConsole.java +++ b/src/main/java/Visualization/Visualizers/VisualizerNESWtoConsole.java @@ -18,11 +18,13 @@ public class VisualizerNESWtoConsole implements Visualizer { int maxHeight; int maxWidth; final int[] isHydrophobic; + Config config; - public VisualizerNESWtoConsole(int[] isHydrophobic) { + public VisualizerNESWtoConsole(int[] isHydrophobic, Config config) { this.maxHeight = 0; this.maxWidth = 0; this.isHydrophobic = isHydrophobic; + this.config = config; } public void drawProtein(ArrayList<Vertex> vertexListOriginal, double fit, int bond, int over, int gen) { @@ -46,32 +48,32 @@ public class VisualizerNESWtoConsole implements Visualizer { switch (cellState) { case Empty: - return Config.consoleEmpty; + return config.getConsoleEmpty(); case Hydrophobic: - return Config.consoleHydrophobic; + return config.getConsoleHydrophobic(); case Hydrophilic: - return Config.consoleHydrophilic; + return config.getConsoleHydrophilic(); case HydrophobicMulti: - return Config.consoleHydrophobicMulti; + return config.getConsoleHydrophobicMulti(); case HydrophilicMulti: - return Config.consoleHydrophilicMulti; + return config.getConsoleHydrophilicMulti(); case Mixed: - return Config.consoleMixed; + return config.getConsoleMixed(); case ConnectionVertical: - return Config.consoleConnectionVertical; + return config.getConsoleConnectionVertical(); case ConnectionHorizontal: - return Config.consoleConnectionHorizontal; + return config.getConsoleConnectionHorizontal(); } // Fallback - return Config.consoleEmpty; + return config.getConsoleEmpty(); } diff --git a/src/main/java/Visualization/Visualizers/VisualizerNESWtoFile.java b/src/main/java/Visualization/Visualizers/VisualizerNESWtoFile.java index 15ba9a6a5231cd7d7ae5d792d34b0fb8a03918d5..ed0b7f78d4596b2eb595e60e3d5f8ee97f1e2f3a 100644 --- a/src/main/java/Visualization/Visualizers/VisualizerNESWtoFile.java +++ b/src/main/java/Visualization/Visualizers/VisualizerNESWtoFile.java @@ -26,14 +26,16 @@ public class VisualizerNESWtoFile implements Visualizer { int margin = pixelsPerCell * 2; int outline = 2; final int[] isHydrophobic; + Config config; - public VisualizerNESWtoFile(String folder, int[] isHydrophobic) { - this.folder = folder; + public VisualizerNESWtoFile(int[] isHydrophobic, Config config) { + this.folder = config.getImageSequencePath(); this.filename = "image.png"; // Default this.maxHeight = 0; this.maxWidth = 0; this.isHydrophobic = isHydrophobic; + this.config = config; } public void drawProtein(ArrayList<Vertex> vertexListOriginal, double fit, int bond, int over, int gen) { @@ -55,12 +57,12 @@ public class VisualizerNESWtoFile implements Visualizer { BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = image.createGraphics(); g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON); - g2.setFont(Config.font); + g2.setFont(config.getFont()); FontMetrics metrics = g2.getFontMetrics(); int ascent = metrics.getAscent(); // Background - g2.setColor(Config.imageBackground); + g2.setColor(config.getImageBackground()); g2.fillRect(0, 0, width, height); for (int yIndex = cellArray.length-1; yIndex >= 0; yIndex--) { @@ -77,27 +79,27 @@ public class VisualizerNESWtoFile implements Visualizer { case Hydrophobic: case HydrophobicMulti: - aminoColor = Config.imageHydrophobic; + aminoColor = config.getImageHydrophobic(); break; case Hydrophilic: case HydrophilicMulti: - aminoColor = Config.imageHydrophilic; + aminoColor = config.getImageHydrophilic(); break; case Mixed: - aminoColor = Config.imageMixed; + aminoColor = config.getImageMixed(); break; case ConnectionVertical: - g2.setColor(Config.imageConnection); + g2.setColor(config.getImageConnection()); g2.fillRect((xIndex * pixelsPerCell) + margin + (pixelsPerCell/2)-outline, (yIndexPosition * pixelsPerCell) + margin, outline * 2, pixelsPerCell); break; case ConnectionHorizontal: - g2.setColor(Config.imageConnection); + g2.setColor(config.getImageConnection()); g2.fillRect((xIndex * pixelsPerCell) + margin, (yIndexPosition * pixelsPerCell) + margin + (pixelsPerCell/2)-outline, pixelsPerCell, outline * 2); @@ -105,14 +107,14 @@ public class VisualizerNESWtoFile implements Visualizer { } if (aminoColor != null) { - g2.setColor(Config.imageOutline); + g2.setColor(config.getImageOutline()); g2.fillRect((xIndex * pixelsPerCell) + margin, (yIndexPosition * pixelsPerCell) + margin, pixelsPerCell, pixelsPerCell); g2.setColor(aminoColor); g2.fillRect((xIndex * pixelsPerCell) + outline + margin, (yIndexPosition * pixelsPerCell) + outline + margin, pixelsPerCell - (outline * 2), pixelsPerCell - (outline * 2)); - g2.setColor(Config.imageAminoText); + g2.setColor(config.getImageAminoText()); String label = ""; for (int aminoIndex : cellArray[yIndex][xIndex].aminoIndexes) { label += aminoIndex + " "; @@ -125,7 +127,7 @@ public class VisualizerNESWtoFile implements Visualizer { } } - g2.setColor(Config.imageText); + g2.setColor(config.getImageText()); String label = "Gen: " + gen + " Fitness: " + String.format("%.4f", fit) + " H/H Bonds: " + bond