Modif Voisinage

Automate/Automate.cpp

+#include "Automate.h"
+
+std::unique_ptr<Automate> Automate::instance = nullptr;

Automate/Automate.h

+#ifndef _AUTOMATE_H
+#define _AUTOMATE_H
+
+#include <memory>
+
+class Automate {
+	private:
+		static std::unique_ptr<Automate> instance;
+		Automate() = default;
+		Automate(const Automate& a) = delete;
+		Automate& operator=(const Automate& a) = delete;
+
+	public:
+		static Automate& getInstance() {
+			if(instance == nullptr) {
+				instance.reset(new Automate);
+			}
+
+			return *instance;
+		}
+		~Automate() = default;
+};
+
+#endif

Fonction_Regle/Fonction.h

 #ifndef _FONCTION_H
 #define _FONCTION_H
 
+#include "../Reseau_Cellule_Etat/reseau_cellule_etats.h"
+#include "../Voisinage/voisinage.hpp"
+
 class Regle {
 	private:
 		int seuilsMin[8];

GUI/autocell.cpp

+#include "autocell.h"
+#include "Reseau_Cellule_Etat/reseau_cellule_etats.h"
+
+#include <QApplication>
+#include <QPushButton>
+#include <QWidget>
+#include <QLineEdit>
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QComboBox>
+#include <QTableWidget>
+#include <QTableWidgetItem>
+#include <QHeaderView>
+#include <QLayoutItem>
+#include <QFont>
+#include <QPushButton>
+#include <QCheckBox>
+#include <QFormLayout>
+#include <QObject>
+#include <string>
+#include <QBrush>
+
+#include <iostream>
+#include <iomanip>
+
+extern EnsembleEtat& enseEtats;
+
+using namespace std;
+
+AutoCell::AutoCell(QWidget* parent):QWidget(parent)
+{
+    this->setWindowTitle("Automate cellulaire");
+    this->setMinimumSize(1150, 650);
+
+    //division en frame de la fenêtre de l'application
+
+    general = new QGridLayout;
+
+    this->setLayout(general);
+
+    //définition de la frame choix du modèle
+
+    win_model_choice = new QWidget;
+    win_model_choice->setStyleSheet("background-color: rgb(204, 209, 209)");
+    win_model_choice->setFixedSize(300, 100);
+
+    lab_model_choice = new QLabel("Choisir un modèle dans la liste :", win_model_choice);
+
+    liste = new QComboBox(win_model_choice);
+    liste->addItem("modèle 1");
+    liste->addItem("modèle 2");
+    liste->addItem("modèle 3");
+    liste->addItem("modèle 4");
+    liste->setStyleSheet("background-color : rgb(251, 252, 252 )");
+
+    connect(liste,SIGNAL(currentIndexChanged(int)),this,SLOT(RAZ()));
+
+    grid_model_choice = new QGridLayout(win_model_choice);
+    grid_model_choice->addWidget(lab_model_choice, 0, 0, 1, 2);
+    grid_model_choice->addWidget(liste, 1,0,3,1);
+
+    general->addWidget(win_model_choice,0,0);
+
+    //définition de la frame initialisation
+
+    win_init = new QWidget;
+    win_init->setFixedWidth(400);
+    lab_init = new QLabel("Configuration du modèle :");
+
+    form_init = new QGridLayout(win_init);
+
+    form_saved_grids = new QFormLayout;
+    form_config = new QFormLayout;
+
+    form_init->addLayout(form_saved_grids, 1,1);
+    form_init->addLayout(form_config, 1,0);
+
+    list_grids = new QComboBox;
+    check_load_grid = new QCheckBox;
+
+
+    edit_largeur = new QLineEdit;
+    edit_largeur->setFixedWidth(30);
+    edit_hauteur= new QLineEdit;
+    edit_hauteur->setFixedWidth(30);
+    check_aleatoire = new QCheckBox;
+    button_valide_init = new QPushButton("Valider");
+    button_valide_init->setFixedWidth(50);
+
+    connect(button_valide_init,SIGNAL(clicked()),this,SLOT(initialiserGrille()));
+
+    form_saved_grids->addRow(tr("Importer une grille"), check_load_grid);
+    form_saved_grids->addRow(tr("Grilles enregistrées"), list_grids);
+    form_saved_grids->addWidget(button_valide_init);
+
+    form_config->addRow(tr("Largeur :"), edit_largeur);
+    form_config->addRow(tr("Hauteur :"), edit_hauteur);
+    form_config->addRow(tr("Remplissage aléatoire"), check_aleatoire);
+
+    form_init->addWidget(lab_init,0,0);
+
+    general->addWidget(win_init,0,1,1,2);
+
+    //définition de la frame "panneau de contrôle de l'exécution"
+
+    win_run_ctrl = new QWidget;
+    lab_run_crtl = new QLabel("Outils de contrôle :", win_run_ctrl);
+    win_run_ctrl->setStyleSheet("background-color: rgb(174, 182, 191)");
+
+    general->addWidget(win_run_ctrl,1,0,2,1);
+
+    //définition de la frame affichage de la grille
+
+    win_grid = new QWidget;
+
+    grid = new QTableWidget(0,0,win_grid);
+
+    //notice
+
+    win_notice = new QWidget;
+    win_notice->setStyleSheet("background-color: rgb(204, 209, 209)");
+    win_notice->setMaximumWidth(300);
+    win_notice->setMinimumWidth(200);
+    lab_notice = new QLabel("Notice :", win_notice);
+
+    general->addWidget(win_notice,0,2,3,1);
+};
+
+void AutoCell::afficherGrille(Reseau& Grille)
+{
+    win_grid = new QWidget;
+
+    unsigned int l = Grille.getLargeur();
+    unsigned int h = Grille.getHauteur();
+
+    delete grid;
+    grid = new QTableWidget(h,l,win_grid);
+    int dim_pixels_h=32; //Taille en pixel.
+    int dim_pixels_v=30;
+
+    grid->setFixedSize((l)*dim_pixels_h, h*dim_pixels_v);
+
+    grid->horizontalHeader()->setVisible(false); //Pas de nom pour les colonnes.
+    grid->verticalHeader()->setVisible(false);
+    grid->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); //Pas de barre pour scroller.
+    grid->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+
+    QSize size(30, 30);
+    QFont serifFont("Times", 8, QFont::DemiBold);
+
+    for(unsigned int i=0; i<h; i++){
+            for(unsigned int j=0; j<l; j++)
+        {
+            //vérifier si les cellules ont ou non été générés (!= nullptr)
+
+            QString indice; indice.setNum(Grille.getReseau()[i][j].getIndEtat());
+
+            QString label; label = QString::fromStdString(enseEtats.getEtat(indice.toInt()).getLabel()); //label de la cellule
+
+            if (grid->item(i,j) == nullptr)
+                grid->setItem(i, j, new QTableWidgetItem(label));
+
+            //afficherCellule
+
+            QColor color; color = enseEtats.getEtat(indice.toInt()).getColor();
+
+            //QColor color(236, 240, 21);
+
+            //QColor color = enseEtats.getEtat((Grille.getReseau()[i][j]).getIndEtat()).getColor(); //couleur de la cellule
+
+            QBrush brush_color;
+            brush_color.setColor(color);
+
+            grid->item(i,j)->setBackground(brush_color.color());
+            grid->item(i,j)->setForeground(Qt::black);
+            grid->item(i,j)->setSizeHint(size);
+            grid->item(i,j)->setFont(serifFont);
+
+            grid->setColumnWidth(j,25);
+        }
+    }
+
+    general->addWidget(win_grid,1,1,2,2);
+
+};
+
+
+void AutoCell::initialiserGrille(){
+    bool ok;
+
+    int l = (edit_largeur->text()).toInt(&ok, 10);
+
+    int h = (edit_hauteur->text()).toInt(&ok, 10);
+
+    QString str_l; str_l.setNum(l);
+    QString str_h; str_h.setNum(h);
+
+    Reseau Grille1(h,l);
+    //Reseau Grille1(12,12);
+
+    this->afficherGrille(Grille1);
+
+}; //méthode à implémenter qui récupère les données du formulaire - penser à réinitialiser les données annexes
+
+
+void AutoCell::RAZ(){
+    delete grid;
+    grid = new QTableWidget(0,0,win_grid);
+    edit_largeur->setText("");
+    edit_hauteur->setText("");
+}

GUI/autocell.h

+#ifndef AUTOCELL_H
+#define AUTOCELL_H
+
+#include "Reseau_Cellule_Etat/reseau_cellule_etats.h"
+
+#include <QApplication>
+#include <QPushButton>
+#include <QWidget>
+#include <QLineEdit>
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QComboBox>
+#include <QTableWidget>
+#include <QTableWidgetItem>
+#include <QHeaderView>
+#include <QLayoutItem>
+#include <QFont>
+#include <QPushButton>
+#include <QCheckBox>
+#include <QFormLayout>
+
+using namespace std;
+
+extern EnsembleEtat& enseEtats;
+
+class AutoCell : public QWidget
+
+{
+    Q_OBJECT
+    QGridLayout* general;
+
+    //définition de la frame choix du modèle
+    QWidget* win_model_choice;
+    QLabel* lab_model_choice;
+    QComboBox *liste;
+    QGridLayout *grid_model_choice;
+
+    //définition de la frame initialisation
+    QWidget* win_init;
+    QLabel* lab_init;
+    QGridLayout* form_init;
+
+    QFormLayout* form_saved_grids;
+    QFormLayout* form_config;
+
+    QComboBox *list_grids;
+    QCheckBox* check_load_grid;
+
+    QLineEdit* edit_largeur;
+    QLineEdit* edit_hauteur;
+    QCheckBox* check_aleatoire;
+    QPushButton* button_valide_init;
+
+    //définition de la frame "panneau de contrôle de l'exécution"
+    QWidget* win_run_ctrl;
+    QLabel* lab_run_crtl;
+
+    //définition de la frame affichage de la grille
+    QWidget* win_grid;
+    QTableWidget* grid;
+
+    //notice
+    QWidget* win_notice;
+    QLabel* lab_notice;
+
+    public:
+    explicit AutoCell(QWidget* parent=nullptr);
+
+    public slots:
+    //void chargerModele();
+    //void listerModele(); //à faire en dernier
+    //void chargerGrille();
+    //void listerGrille(); //déjà réfléchir à la recopie
+    //Reseau initialiserGrille(); //méthode à implémenter qui récupère les données du formulaire - penser à réinitialiser les données annexes
+    void afficherGrille(Reseau&); //affiche une grille
+    void initialiserGrille();
+    void RAZ();
+    //void faireSimulation();
+    //void sauvegarderGrille();
+    //void modifierGrille();//à implémenter
+
+};
+
+
+#endif // AUTOCELL_H

Makefile

-CC = g++
-FLAGS = -O3 -Wall -Wextra -Werror -pedantic-errors -std=c++17
-OBJS = main.o
-PROJNAME = projetLO21
-
-$(PROJNAME): $(OBJS)
-	$(CC) $(FLAGS) -o $(PROJNAME) $^
-
-%.o: %.cpp
-	$(CC) $(FLAGS) -c $< -o $@
-
-clean:
-	rm -f $(OBJS) $(PROJNAME)
-

Reseau_Cellule_Etat/main.cpp

-#include <iostream>
-#include <iomanip>
-#include <reseau_cellule_etats.h>
+#include "autocell.h"
+#include "reseau_cellule_etats.h"
+
+#include <QApplication>
+#include <QPushButton>
+#include <QWidget>
+#include <QLineEdit>
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QComboBox>
+#include <QTableWidget>
+#include <QTableWidgetItem>
+#include <QHeaderView>
+#include <QLayoutItem>
+#include <QFont>
 
 using namespace std;
 
-int main()
+EnsembleEtat &enseEtats = EnsembleEtat::getInstance();
+
+int main(int argc, char* argv[])
 {
-    std::cout<<"--- Affichage d'une grille initialisee par defaut --- \n";
+    QApplication app(argc, argv);
 
     EnsembleEtat &enseEtats = EnsembleEtat::getInstance();
 
-    enseEtats.ajouterEtat(0, "vivant", "white");
-    enseEtats.ajouterEtat(1, "mort", "black");
-
-    //std::cout<<enseEtats.getEtat(0).getLabel()<<endl;
+    enseEtats.ajouterEtat(0, "vivant", 100, 30, 22);
+    enseEtats.ajouterEtat(1, "mort", 236, 240, 21);
 
-    int largeur = 10;
+    int largeur = 15;
     int hauteur = 12;
 
     Reseau Grille(hauteur, largeur);
-    Grille.affiche();
 
-    return 0;
+    AutoCell autocell;
+    autocell.afficherGrille(Grille);
+    autocell.show();
+
+    return app.exec();
 }
+
+

Reseau_Cellule_Etat/reseau_cellule_etats.cpp

@@ -2,6 +2,8 @@
 #include <iostream>
 #include <iomanip>
 
+using namespace std;
+
 //méthodes de la classe EnsembleEtat
 
 EnsembleEtat::Handler EnsembleEtat::handler;
@@ -25,8 +27,8 @@ void EnsembleEtat::libererInstance() {
     handler.instance = nullptr;
 }
 
-void EnsembleEtat::ajouterEtat(unsigned int ind, std::string lab,std::string col){
-    handler.instance->ensEtats[nbEtats] = new Etat(ind, lab, col);
+void EnsembleEtat::ajouterEtat(unsigned int ind, std::string lab,int r, int g, int b){
+    handler.instance->ensEtats[nbEtats] = new Etat(ind, lab, r, g, b);
     nbEtats++;
 }
 

Reseau_Cellule_Etat/reseau_cellule_etats.h

 #pragma once
 #include <iostream>
 #include <array>
+#include <QColor>
+
+using namespace std;
 
 class Cellule{
 private:
@@ -11,26 +14,35 @@ private:
     //inline Cellule():indEtat(0), abs(0), ord(0){};
     void initCellule(const unsigned int ind, const unsigned int &x, const unsigned int &y);
     friend class Reseau;
+<<<<<<< HEAD
     friend class RegleVoisinage;
     friend class RegleVoisinageNeumann;
     friend class RegleVoisinageMoore;
 
 
+=======
+public:
+    inline unsigned int getIndEtat() const {return indEtat;}
+>>>>>>> f7848295cdeed771bfc93a109c01fd440c2d61b7
 };
 
 class Etat{
 private:
     unsigned int indice;
     std::string label;
-    std::string color;
-    inline Etat(unsigned int ind, std::string lab, std::string col):
-    indice(ind),label(lab),color(col){}; //constructeur privé (l'utilisateur ne doit pas pouvoir créer un Etat par ce biais)
+    QColor color;
+    inline Etat(unsigned int ind, std::string lab, int r = 0, int g = 0, int b = 0):
+    indice(ind),label(lab),color(r,g,b){};
+    inline Etat(unsigned int ind, std::string lab, QColor col):
+    indice(ind),label(lab),color(col){};//constructeur privé (l'utilisateur ne doit pas pouvoir créer un Etat par ce biais)
     friend class EnsembleEtat;
 
 public:
-    inline std::string& getLabel(){return label;}
+    inline std::string getLabel(){return label;}
+    inline QColor getColor(){return color;}
 };
 
+
 class EnsembleEtat{ //singleton qui regroupe l'ensemble des états
 private:          //permet d'éviter que chaque cellule inclue une instance d'Etat
     size_t nbEtats = 0;
@@ -48,7 +60,7 @@ private:          //permet d'éviter que chaque cellule inclue une instance d'Et
     EnsembleEtat operator=(const EnsembleEtat&) = delete;
 
 public:
-    void ajouterEtat(unsigned int ind, std::string lab, std::string col);
+    void ajouterEtat(unsigned int ind, std::string lab,int r = 0, int g = 0, int b = 0);
     void supprimerEtat(const unsigned int ind);
     static EnsembleEtat& getInstance();
     static void libererInstance();
@@ -74,6 +86,9 @@ public:
                 for(unsigned int j=0; j<largeur; j++)
                     reseau[i][j].initCellule(0,i,j);
     }*/
+    inline int getLargeur() const {return largeur;};
+    inline int getHauteur() const {return hauteur;};
+    inline Cellule** getReseau() const {return reseau;};
     Reseau(const unsigned int &h, const unsigned int &l);
     ~Reseau();
     void affiche();

Voisinage/voisinage.cpp

@@ -2,17 +2,10 @@
 #include<math.h>
 
 void Voisinage::setr(unsigned int rayon){
-    rayon = -1;
-
-	while (rayon< 0){
-		printf("Entrez le ratonde voisinage (0 pour le voisinage arbitraire):\n ");
-		scanf("%d", &rayon);
-
-		if(rayon >= 0){
-			r = rayon;
-		}
-		else printf("Rayon incorrect !\n");
+   if(rayon >= 0){
+		r = rayon;
 	}
+	else throw ("Rayon incorrect !\n");
 	 
 }
 

Voisinage/voisinage.hpp

@@ -13,6 +13,8 @@
 #include "../Reseau_Cellule_Etat/reseau_cellule_etats.h"
 #include <string.h>
 
+#include "Reseau_Cellule_Etat/reseau_cellule_etats.h"
+
 using namespace std;
 
 #include <vector>
@@ -59,7 +61,11 @@ public:
 
     Voisinage();
     ~Voisinage();
+
     Cellule getCelluleCentre()const {return *celluleCentre;}
+
+    const Cellule* getCelluleCentre()const {return celluleCentre;}
+
     void setr(unsigned int rayon);
     unsigned int getr() const {return r;}
     VoisinageIterator *creerIterator()const{

qmake

+QT += widgets
+
+SOURCES += GUI/autocell.cpp
+SOURCES += Voisinage/voisinage.cpp
+SOURCES += Reseau_Cellule_Etat/reseau_cellule_etats.cpp
+SOURCES += Reseau_Cellule_Etat/main.cpp
+SOURCES += Fonction_Regle/Fonction.cpp
+SOURCES += Automate/Automate.cpp
+
+HEADERS += ./GUI/autocell.h
+HEADERS += ./Cellulut/Cellulut/fonction.h
+HEADERS += ./Voisinage/voisinage.hpp
+HEADERS += ./Reseau_Cellule_Etat/reseau_cellule_etats.h
+HEADERS += ./Fonction_Regle/Fonction.h
+HEADERS += ./Automate/Automate.h