comparison src/main.cpp @ 0:add35537fdbb tip

Initial import

+//  Copyright 2011, Ian Hobson.
+//
+//  This file is part of gpsynth.
+//
+//  gpsynth is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  gpsynth is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with gpsynth in the file COPYING. 
+//  If not, see http://www.gnu.org/licenses/.
+
+#include "file_comparer.hpp"
+#include "graph_helpers.hpp"
+#include "logger.hpp"
+#include "population.hpp"
+#include "program_options.hpp"
+#include "sc_converter.hpp"
+#include "sc_default_grammar.hpp"
+#include "sc_evaluator.hpp"
+#include "sc_grammar.hpp"
+
+#include "boost/filesystem.hpp"
+#include "boost/shared_array.hpp"
+
+#include <algorithm>
+#include <ctime>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+const std::string g_test_grammar_path = "/tmp/sc.json";
+
+template<typename T>
+void SaveToFile(const T& value, const std::string& file_path) {
+  std::ofstream file(file_path.c_str());
+  file << value;
+}
+
+void TestCrossover() {
+  sc::Grammar grammar(g_test_grammar_path);
+  sc::Converter converter(grammar);
+  sg::Graph parent_1;
+  sg::Graph parent_2;
+  grammar.SetMaximumDepth(2);
+  grammar.RandomGraph(parent_1);
+  grammar.RandomGraph(parent_2);
+  sg::Vertex crossover_1;
+  sg::Vertex crossover_2;
+  grammar.PickCrossoverNodes(parent_1, parent_2, &crossover_1, &crossover_2);
+  // swap the subtrees
+  sg::Graph child_1;
+  sg::Graph child_2;
+  SwapSubTrees(crossover_1, crossover_2, parent_1, parent_2, child_1, child_2);
+  SaveToFile(converter.ToDOT(parent_1), "/tmp/parent1.dot");
+  SaveToFile(converter.ToDOT(parent_2), "/tmp/parent2.dot");
+  SaveToFile(converter.ToDOT(child_1), "/tmp/child1.dot");
+  SaveToFile(converter.ToDOT(child_2), "/tmp/child2.dot");
+}
+
+void TestMutationReplaceSubtree() {
+  sc::Grammar grammar(g_test_grammar_path);
+  sc::Converter converter(grammar);
+  sg::Graph graph;
+  grammar.RandomGraph(graph);
+  SaveToFile(converter.ToDOT(graph), "/tmp/mutation_str_before.dot");
+  grammar.MutationReplaceSubTree(graph);
+  SaveToFile(converter.ToDOT(graph), "/tmp/mutation_str_after.dot");
+}
+
+void TestMutationReplaceCommand() {
+  sc::Grammar grammar(g_test_grammar_path);
+  sc::Converter converter(grammar);
+  sg::Graph graph;
+  grammar.SetMaximumDepth(3);
+  grammar.RandomGraph(graph);
+  SaveToFile(converter.ToDOT(graph), "/tmp/mutation_str_before.dot");
+  SaveToFile(converter.ToSynthDef(graph, "before"),
+             "/tmp/mutation_str_before.sc");
+  grammar.MutationReplaceCommand(graph);
+  SaveToFile(converter.ToDOT(graph), "/tmp/mutation_str_after.dot");
+  SaveToFile(converter.ToSynthDef(graph, "after"),
+             "/tmp/mutation_str_after.sc");
+}
+
+void TestMutationInsertCommand() {
+  sc::Grammar grammar(g_test_grammar_path);
+  sc::Converter converter(grammar);
+  sg::Graph graph;
+  grammar.SetMaximumDepth(4);
+  grammar.RandomGraph(graph);
+  SaveToFile(converter.ToDOT(graph), "/tmp/mutation_str_before.dot");
+  SaveToFile(converter.ToSynthDef(graph, "before"),
+             "/tmp/mutation_str_before.sc");
+  grammar.MutationInsertCommand(graph);
+  SaveToFile(converter.ToDOT(graph), "/tmp/mutation_str_after.dot");
+  SaveToFile(converter.ToSynthDef(graph, "after"),
+             "/tmp/mutation_str_after.sc");
+}
+
+void DoEvolution(const ProgramOptions& settings) {
+  // prepare the file comparer
+  dsp::FileComparer target(settings.fitness_features_,
+                           static_cast<int>(settings.analysis_window_size_),
+                           static_cast<int>(settings.analysis_hop_size_));
+  target.SetTargetFile(settings.target_path_);
+  // prepare the supercollider objects
+  std::string grammar_json;
+  if (settings.grammar_path_.empty()) {
+    grammar_json.assign(sc::g_default_grammar);
+  } else {
+    grammar_json = stdx::LoadFile(settings.grammar_path_);
+  }
+  sc::Grammar grammar(grammar_json);
+  grammar.SetMaximumDepth(static_cast<int>(settings.maximum_tree_depth_));
+  sc::Evaluator evaluator(grammar,
+                          settings.sc_app_path_,
+                          target,
+                          static_cast<int>(settings.core_limit_));
+  sc::Converter converter(grammar);
+  // set up the population
+  Population population(&grammar, &converter, &evaluator);
+  population.SetWorkFolder(settings.work_folder_);
+  population.SetFitnessThreshold(settings.fitness_threshold_);
+  population.SetCrossoverRate(settings.crossover_rate_);
+  population.SetMutationRate(settings.mutation_rate_);
+  population.SetTournamentSize(static_cast<int>(settings.tournament_size_));
+  population.SetReproduceBest(settings.reproduce_best_individual_);
+  population.InitializePopulation(settings.population_size_);
+  population.SetKeepTempFolders(settings.keep_temp_folders_);
+  // run the evolution loop
+  population.Evolve(static_cast<int>(settings.generations_));
+}
+
+int main(int argument_count, const char* arguments[])
+{
+  srand(static_cast<unsigned int>(time(NULL)));
+  try {
+    // parse the command line options
+    ProgramOptions settings;
+    ParseCommandLine(argument_count, arguments, &settings);
+    DoEvolution(settings);
+    
+    //TestCrossover();
+    //TestMutationReplaceSubtree();
+    //TestMutationInsertCommand();
+    //TestMutationReplaceCommand();
+  } catch (const std::exception& e) {
+    std::stringstream message;
+    message << "Exception: " << e.what() << '\n';
+    logger::Log(message.str());
+    logger::Flush();
+    return -1;
+  }
+  logger::Flush();
+}