removed video option, began benchmarking

include/genimg/parseargs.hh

@@ -4,7 +4,7 @@
 #include <filesystem>
 #include <tuple>
 
-std::tuple<std::filesystem::path, std::filesystem::path, bool, int, int, bool>
+std::tuple<std::filesystem::path, std::filesystem::path, int, int, bool>
 parse_args(int, char **);
 
 #endif /* GENETIC_IMAGE_INCLUDE_GENIMG_PARSEARGS_HH_ */

report/report.org

@@ -10,6 +10,7 @@
 #+LATEX_HEADER: \usepackage{xcolor} \usepackage{hyperref}
 #+LATEX_HEADER: \hypersetup{colorlinks=true,linkbordercolor=red,linkcolor=blue,pdfborderstyle={/S/U/W 1}}
 #+STARTUP: latexpreview
+#+OPTIONS: toc:nil |:nil
 
 * Sujet
 
@@ -46,15 +47,30 @@ d’optimisation ~-O3~ et ~-flto~.
 Voici également ci-dessous la liste des options et arguments possibles
 concernant l’exécution du logiciel.
 #+begin_src text
-$ ./bin/genetic-image -h
+  $ ./bin/genetic-image -h
-Allowed options:
+  Allowed options:
-  -h [ --help ]           Display this help message
+    -h [ --help ]           Display this help message
-  -i [ --input ] arg      Input image
+    -i [ --input ] arg      Input image
-  -o [ --output ] arg     Image or video output path (default: input path +
+    -o [ --output ] arg     Image output path (default: input path + "_output")
-                          "_output")
+    -m [ --method ] arg     Method number to be used (default: 1)
-  -m [ --method ] arg     Method number to be used (default: 1)
+    -n [ --iterations ] arg Number of iterations (default: 5000)
-  -n [ --iterations ] arg Number of iterations (default: 5000)
+    -v [ --verbose ]        Enables verbosity
-  -v [ --video ]          Enable video output
+#+end_src
+
+Voici la ligne de commande utilisée depuis le répertoire ~build~ afin de pouvoir
+obtenir un temps d’exécution :
+#+begin_src shell
+  perf stat -r {nombreExécutions} -B ./bin/genetic-image \
+       -i ../img/mahakala-monochrome.jpg -o output.png   \
+       -n {nombreIterations} -m 1
+#+end_src
+
+Les deux éléments entre accolades sont à remplacer par leur valeur, par exemple
+afin d’exécuter dix fois le programme avec vingt améliorations, il faudrait
+exécuter ceci :
+#+begin_src shell
+  perf stat -r 1 -B ./bin/genetic-image \
+       -i ../img/mahakala-monochrome.jpg -o output.png -n 20 -m 1
 #+end_src
 
 ** Méthode naïve
@@ -67,25 +83,112 @@ en l’état essaiera d’appliquer des couleurs n’existant pas dans l’image
 référence, voire complètement à l’opposées de la palette de couleurs de l’image
 de référence.
 
-Voici la ligne de commande utilisée depuis le répertoire ~build~ afin de pouvoir
+Voici les moyennes de temps d’exécution selon le nombre d’itérations réussies
-obtenir un temps d’exécution :
+sur le nombre d’exécutions indiqué.
-#+begin_src shell
+#+tblname: temps1
-  perf stat -r nombreDExécutions -B ./bin/genetic-image \
+|                   / |                 < |         < |                   < |
-       -i ../img/mahakala-monochrome.jpg -o output.png -n 200 -m 1
+| Nombre d’itérations | Temps d’exécution | Variation | Nombre d’exécutions |
+|---------------------+-------------------+-----------+---------------------|
+|                  10 |           0.08371 |   0.00249 |                 200 |
+|                  50 |            1.0966 |    0.0320 |                 100 |
+|                 100 |             3.835 |     0.118 |                  50 |
+|                 200 |            13.274 |     0.547 |                  20 |
+|                 500 |             73.47 |      2.49 |                  10 |
+|                1000 |            293.11 |     10.96 |                   5 |
+#+begin_src gnuplot :var data=temps1 :file temps1.png
+  reset
+  set title "Temps d’exécution"
+  set size ratio square
+  set key box linestyle -1
+  set key top left
+
+  set xlabel "Nombre d’itérations"
+  set xrange[0 : 7]
+  set xtics nomirror rotate by -45
+
+  set yrange [0 : *]
+  set ylabel "Temps (s)"
+  set ytics nomirror
+  set log y 2;
+
+  set y2range [* : *]
+  set y2label "Variation (s)"
+  set log y2 2
+  set y2tics 0,0.5,3.5
+
+  set style data points
+  plot data u 2:xticlabels(1) axis x1y1 lw 3 title 'Temps', \
+       data u 3:xticlabels(1) axis x1y2 lw 3 title 'Variation'
 #+end_src
 
-|                            / |                   < | <                       |
+#+RESULTS:
-| nombre d’itérations réussies | nombre d’exécutions | temps d’exécution moyen |
+[[file:temps1.png]]
-|------------------------------+---------------------+-------------------------|
-|                           10 |                 100 | 0.09447s (±0.02%)       |
-|                           50 |                 100 | 1.1331s (±2.85%)        |
-|                          100 |                  50 |                         |
-|                          200 |                  20 |                         |
-|                          500 |                  10 |                         |
-|                         1000 |                   5 |                         |
 
 Naturellement, la variation en temps d’exécution croît en même temps que le
 nombre d’améliorations nécessaires à apporter à l’image à améliorer, dû à la
 nature aléatoire de l’algorithme. Cependant, on constate également une
 croissance importante du temps d’exécution suivant également ce nombre
 d’itérations réussies.
+
+** Réduction du panel des couleurs
+
+Constatant que la majorité des échecs d’ajout de formes de couleur par la
+première méthode échouent dû à une couleur incorrecte, voire n’appartenant pas à
+l’image de référence, j’ai décidé de restreindre les possibilités de couleurs
+parmis lesquelles le hasard peut choisir à la liste des couleurs présentes dans
+l’image de référence uniquement. Ce choix se fait donc via l’implémentation d’un
+set de valeurs uniques représentant les couleurs trouvées dans l’image de
+référence, leur détection étant réalisée avec des threads parallèles pour plus
+de rapidité à l’exécution. Cette méthode est celle implémentée dans la fonction
+~method2()~ dans ~src/methods.cc~.
+
+Voici les moyennes de temps d’exécution selon le nombre d’itérations réussies
+sur le nombre d’exécutions indiqué.
+#+tblname: temps2
+|                   / | <                 | <         |                   < |
+| Nombre d’itérations | Temps d’exécution | Variation | Nombre d’exécutions |
+|---------------------+-------------------+-----------+---------------------|
+|                  10 | 0.051697          | 0.000413  |                 200 |
+|                  50 |                   |           |                 100 |
+|                 100 |                   |           |                  50 |
+|                 200 |                   |           |                  20 |
+|                 500 |                   |           |                  10 |
+|                1000 |                   |           |                   5 |
+#+begin_src gnuplot :var data=temps2 :file temps2.png
+  reset
+  set title "Temps d’exécution"
+  set size ratio square
+  set key box linestyle -1
+  set key top left
+
+  set xlabel "Nombre d’itérations"
+  set xrange[0 : 7]
+  set xtics nomirror rotate by -45
+
+  set yrange [0 : *]
+  set ylabel "Temps (s)"
+  set ytics nomirror
+  set log y 2;
+
+  set y2range [* : *]
+  set y2label "Variation (s)"
+  set log y2 2
+  set y2tics 0,0.5,3.5
+
+  set style data points
+  plot data u 2:xticlabels(1) axis x1y1 lw 3 title 'Temps', \
+       data u 3:xticlabels(1) axis x1y2 lw 3 title 'Variation'
+#+end_src
+
+On peut remarquer une très nette amélioration de la rapidité d’exécution du
+logiciel. Étant donné que cette modification ne sera à priori pas en conflit
+avec d’autres méthodes, cette amélioration sera conservée pour toutes les autres
+avancées suivantes.
+
+** Une taille des formes aléatoire mais contrôlée
+
+Une autre méthode peut être de limiter
+
+** Concurrence entre threads
+
+Une utilisation na

src/main.cc

@@ -4,12 +4,11 @@
 #include <iostream>
 
 int main(int ac, char **av) {
-  auto const [input_file, output_file, video_output, iterations, method,
+  auto const [input_file, output_file, iterations, method,
               verbose] = parse_args(ac, av);
   spdlog::set_level(verbose ? spdlog::level::debug : spdlog::level::info);
   spdlog::debug("Input file:\t{}", input_file.native());
   spdlog::debug("Output file:\t{}", output_file.native());
-  spdlog::debug("Video output:\t{}", video_output);
   spdlog::debug("Iterations:\t{}", iterations);
   auto [input_image, process_image] = init_image(input_file.native());
   std::random_device rd;

src/parseargs.cc

@@ -16,21 +16,17 @@ void processFilenames(po::variables_map const &vm, path const &t_input,
   } else if (!t_output.has_extension()) {
     t_output.replace_extension(".png");
   }
-  if (vm.count("video")) {
-    t_output.replace_extension(".mp4");
-  }
 }
 
-std::tuple<path, path, bool, int, int, bool> parse_args(int t_ac, char **t_av) {
+std::tuple<path, path, int, int, bool> parse_args(int t_ac, char **t_av) {
   po::options_description desc("Allowed options");
   desc.add_options()
       ("help,h", "Display this help message")
       ("input,i", po::value<path>(), "Input image")
       ("output,o", po::value<path>(),
-       "Image or video output path (default: input path + \"_output\")")
+       "Image output path (default: input path + \"_output\")")
       ("method,m", po::value<int>(), "Method number to be used (default: 1)")
       ("iterations,n", po::value<int>(), "Number of iterations (default: 5000)")
-      ("video,V", "Enable video output")
       ("verbose,v", "Enables verbosity");
   po::variables_map vm;
   po::store(po::parse_command_line(t_ac, t_av, desc), vm);
@@ -45,11 +41,9 @@ std::tuple<path, path, bool, int, int, bool> parse_args(int t_ac, char **t_av) {
       vm.count("output") ? vm["output"].as<path>() : input_path.filename();
   processFilenames(vm, input_path, output_path);
 
-  return std::make_tuple(
+  return std::make_tuple(input_path, output_path,
-      input_path,
+                         vm.count("iterations") ? vm["iterations"].as<int>()
-      output_path,
+                                                : DEFAULT_ITERATIONS,
-      vm.count("video") ? true : false,
+                         vm.count("method") ? vm["method"].as<int>() : 1,
-      vm.count("iterations") ? vm["iterations"].as<int>() : DEFAULT_ITERATIONS,
+                         vm.count("verbose") ? true : false);
-      vm.count("method") ? vm["method"].as<int>() : 1,
-      vm.count("verbose") ? true : false);
 }