- Ajout règle de voisinage Moore et Von Neumann #30 #31

- Création du fichier test pour Moore (à faire #38)
- Ajout include dans NeighborhoodRule.hpp

include/mooreNeighborhoodRule.hpp

+/**
+\file mooreNeighborhoodRule.hpp
+\date 13/05/2021
+\author Eugene Pin
+\version 1
+\brief mooreNeighborhoodRule
+
+Contient la classe de la règle de Moore (semblable à VonNeumann avec les diagonales en plus).
+**/
+
+#ifndef MOORENEIGHBOURHOODRULE_HPP
+#define MOORENEIGHBOURHOODRULE_HPP
+#include "neighborhoodrule.hpp"
+#include "neighborhood.hpp"
+
+class mooreNeighborhoodRule : public NeighborhoodRule
+{
+    //! \brief Rayon du voisinage (en nombre de cellule)
+    int radius;
+    NeighborhoodFormat format;
+public:
+    mooreNeighborhoodRule(int _radius = 1);
+
+    //! \brief Retourne l'ensemble des voisins d'une cellule de position 'pos' sur la grille 'grid' sous la forme d'une structure 'Neighborhood'
+    //! \return L'ensemble des voisins de la cellule à 'pos'
+    Neighborhood getNeighborhood(const Grid& grid, Coord pos) const;
+
+    //! \brief Retourne 'format' de Moore dans un vecteur (méthode dérivée)
+    //! \return Retourne les formats de voisinage possible dans un std::vector.
+    std::vector<NeighborhoodFormat> getFormats() const;
+};
+
+#endif // MOORENEIGHBOURHOODRULE_HPP

include/neighborhood.hpp

@@ -55,6 +55,8 @@ public:
     void addNeighbor(Coord c, unsigned s) {
 		if(isUnique(c))
 			neighborPositions.push_back(make_pair(c, s));
+        else
+            throw NeighborhoodException("La coordonnée existe déjà. \n");
 	}
 
 };

include/neighborhoodrule.hpp

@@ -16,9 +16,8 @@ Cette classe peut aussi fournir l'ensemble des positions de voisins qu'elle peut
 #include <vector>
 
 #include "coord.hpp"
-
-class Grid;
-class Neighborhood;
+#include "grid.h"
+#include "neighborhood.hpp"
 
 /**
 \struct NeighborhoodFormat

include/vonNeumannNeighborhoodRule.hpp

+/**
+\file vonNeumannNeighborhoodRule.hpp
+\date 13/05/2021
+\author Eugene Pin
+\version 1
+\brief vonNeumannNeighborhoodRule
+
+Contient la classe de la règle de Von Neumann.
+**/
+
+#ifndef VONNEUMANNNEIGHBORHOODRULE_HPP
+#define VONNEUMANNNEIGHBORHOODRULE_HPP
+
+#include "neighborhoodrule.hpp"
+#include "neighborhood.hpp"
+
+class vonNeumannNeighborhoodRule : public NeighborhoodRule
+{
+    //! \brief Rayon du voisinage (en nombre de cellule)
+    int radius;
+    NeighborhoodFormat format;
+public:
+    vonNeumannNeighborhoodRule(int _radius = 1);
+
+    //! \brief Retourne l'ensemble des voisins d'une cellule de position 'pos' sur la grille 'grid' sous la forme d'une structure 'Neighborhood'
+    //! \return L'ensemble des voisins de la cellule à 'pos'
+    Neighborhood getNeighborhood(const Grid& grid, Coord pos) const;
+
+    //! \brief Retourne 'format' de Moore dans un vecteur (méthode dérivée)
+    //! \return Retourne les formats de voisinage possible dans un std::vector.
+    std::vector<NeighborhoodFormat> getFormats() const;
+};
+
+#endif // VONNEUMANNNEIGHBORHOODRULE_HPP

src/mooreNeighborhoodRule.cpp

+#include "mooreNeighborhoodRule.hpp"
+
+mooreNeighborhoodRule::mooreNeighborhoodRule(int _radius) : radius(_radius)
+{
+    if(_radius == 0)
+        throw NeighborhoodException("Le rayon ne peut pas être égal à 0");
+    // Les coordonnées sont copiées dans le vecteur
+    // N(i,j) = {(k, l)|abs(k−i) ≤ r et abs(l−j) ≤ r} ;
+    Coord newCord;
+    for(int i = -radius; i <= radius; i++){
+        for(int j = -radius; j <= radius; j++){
+            newCord.x = i;
+            newCord.y = j;
+            format.positions.push_back(newCord);
+        }
+    }
+}
+
+Neighborhood mooreNeighborhoodRule::getNeighborhood(const Grid& grid, Coord pos) const
+{
+    Neighborhood newNeighborhood;
+    // Coordonnées des voisins dans la grille
+    Coord gridCoord;
+    std::vector<Coord>::const_iterator it = format.positions.begin();
+    for (it = format.positions.begin() ; it != format.positions.end(); ++it) {
+        // Calcul des coordonnées du voisin sur la grille
+        gridCoord.x = pos.x + it->x;
+        gridCoord.y = pos.y + it->y;
+        // Ajout du nouveau voisin <Coordonnée_relative, état>
+        newNeighborhood.addNeighbor(*it , grid.get_state(gridCoord.x, gridCoord.y));
+    }
+    return newNeighborhood;
+}
+
+std::vector<NeighborhoodFormat> mooreNeighborhoodRule::getFormats() const
+{
+    std::vector<NeighborhoodFormat> vector;
+    vector.push_back(format);
+    return vector;
+}
+

src/src.pro

@@ -15,17 +15,21 @@ SOURCES += \
     arbitraryneighborhoodrule.cpp \
     gridview.cpp \
     main.cpp \
+    mooreNeighborhoodRule.cpp \
     propertyvisitors.cpp \
     neighborhood.cpp \
     structurereader.cpp \
     interface.cpp \
     grid.cpp \
-    history.cpp
+    history.cpp \
+    vonNeumannNeighborhoodRule.cpp
 
 HEADERS += \
     ../include/coord.hpp \
     ../include/neighborhoodrule.hpp \
     ../include/arbitraryneighborhoodrule.hpp \
+    ../include/mooreNeighborhoodrule.hpp \
+    ../include/vonNeumannNeighborhoodRule.hpp \
     ../include/property.hpp \
     ../include/propertyvisitors.hpp \
     ../include/structure.hpp \

src/vonNeumannNeighborhoodRule.cpp

+#include "vonNeumannNeighborhoodRule.hpp"
+
+vonNeumannNeighborhoodRule::vonNeumannNeighborhoodRule(int _radius) : radius(_radius)
+{
+    if(_radius == 0)
+        throw NeighborhoodException("Le rayon ne peut pas être égal à 0");
+    // Les coordonnées sont copiées dans le vecteur
+    // J'ai repris l'implémentation du voisinage de Moore, sauf que les cellules qui ne respectent pas la formule sont exclues
+    // N(i,j) = {(k, l)|abs(k − i) + abs(l − j) ≤ r}
+    Coord newCord;
+    for(int i = -radius; i <= radius; i++){
+        for(int j = -radius; j <= radius; j++){
+            if( abs(i+j) <= radius) {
+                newCord.x = i;
+                newCord.y = j;
+                format.positions.push_back(newCord);
+            }
+        }
+    }
+}
+
+Neighborhood vonNeumannNeighborhoodRule::getNeighborhood(const Grid& grid, Coord pos) const
+{
+    Neighborhood newNeighborhood;
+    // Coordonnées des voisins dans la grille
+    Coord gridCoord;
+    std::vector<Coord>::const_iterator it = format.positions.begin();
+    for (it = format.positions.begin() ; it != format.positions.end(); ++it) {
+        // Calcul des coordonnées du voisin sur la grille
+        gridCoord.x = pos.x + it->x;
+        gridCoord.y = pos.y + it->y;
+        // Ajout du nouveau voisin <Coordonnée_relative, état>
+        newNeighborhood.addNeighbor(*it , grid.get_state(gridCoord.x, gridCoord.y));
+    }
+    return newNeighborhood;
+}
+
+std::vector<NeighborhoodFormat> vonNeumannNeighborhoodRule::getFormats() const
+{
+    std::vector<NeighborhoodFormat> vector;
+    vector.push_back(format);
+    return vector;
+}
+

tests/cellulut_tests.hpp

@@ -14,6 +14,7 @@ private slots:
     void test_coord();
     void test_history();
     void test_grid();
+    void test_mooreNeighborhoodRule();
 
     void test_rle_structurereader();
     void test_json_structurereader();

tests/history_test.cpp

@@ -22,9 +22,6 @@ void CellulutTests::test_history()
     historyTest.pushGrid(gridTest2);
     QVERIFY(historyTest.isEmpty() == false);
 
-    // Remarque : pour push grid, ne serait-il pas mieux d'utiliser des pointeurs sur une grille ? Dans ce cas, on fait
-    // une copie d'une grille. On a donc deux grilles identiques en mémoire : une dans la pile et une autre qu'on utilera plus
-
     // On pop la première grille puis la deuxième
     Grid popGrid = historyTest.popGrid();
     QCOMPARE(popGrid.get_state(3,3), 3);

tests/mooreNeighborhoodRule_test.cpp

+#include <QtTest/QtTest>
+#include <algorithm>
+#include "cellulut_tests.hpp"
+
+#include "mooreNeighborhoodRule.hpp"
+
+void CellulutTests::test_mooreNeighborhoodRule() {
+    mooreNeighborhoodRule newMoore;
+}

tests/tests.pro

@@ -20,16 +20,19 @@ SOURCES += \
     ../src/arbitraryneighborhoodrule.cpp \
     ../src/history.cpp \
     ../src/grid.cpp \
+    ../src/mooreNeighborhoodRule.cpp \
     arbitraryneighborhoodrule_test.cpp \
     coord_tests.cpp \
     factory_tests.cpp \
     grid_test.cpp \
     history_test.cpp \
+    mooreNeighborhoodRule_test.cpp \
     property_test.cpp \
     propertyvisitors_test.cpp \
     cellulut_tests.cpp \
     structure_test.cpp \
     structurereader_tests.cpp
+    mooreNeighborhoodRule_test.cpp
 
 HEADERS += \
     cellulut_tests.hpp