CHanged static Config to object.

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;
+    }
+
 }

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();

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());
         }
     }
 }

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;

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();
     }
 
 

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