Merge branche repereAgglo

Controleur/controleAffichage.c

@@ -28,7 +28,7 @@ void affichageMenuContinu(sfRenderWindow *const window, sfRenderTexture *renderT
 }
 
 
-uint32_t affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderTexture, sfSprite *renderSprite, PointConverti *tabPointsConvertis, uint32_t nbElements, sfCircleShape *tabPointeursCercle[nbElements], const Mode mode)
+uint32_t affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderTexture, sfSprite *renderSprite, PointConverti *tabPointConvertis, Point *tabPoint, uint32_t nbElements, uint32_t  *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], AgglomeratConverti *agglos, uint32_t nbAgglos, sfCircleShape *tabPointeursCercleAgglos[nbAgglos], const Mode mode)
 {
 	sfEvent event;
 
@@ -57,7 +57,21 @@ uint32_t affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderText
 			sfRenderWindow_display(window);
 		}
 
-		afficherPoint(renderTexture, tabPointsConvertis[i].position, &tabPointeursCercle[i]);
+		afficherPoint(renderTexture, tabPointConvertis[i].position, &tabPointeursCercle[i]);
+
+		if(mode == GLOBAL)
+		{
+			if(!(tabPoint[i].type == AGGLOMERAT))
+			{
+				afficherPoint(renderTexture, tabPointConvertis[i].position, &tabPointeursCercle[*nbPointsAffiches]);
+				*nbPointsAffiches += 1;
+			}
+		}
+
+		else
+		{
+			afficherPoint(renderTexture, tabPointConvertis[i].position, &tabPointeursCercle[i]);
+		}
 
 		if(mode == PBP_MANUAL)
 		{
@@ -96,6 +110,14 @@ uint32_t affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderText
 		}
 	}
 
+	if(mode == GLOBAL)
+	{
+		for(uint32_t i = 0; i < nbAgglos; i++)
+		{
+			afficherAgglo(renderTexture, &agglos[i], &tabPointeursCercleAgglos[i], nbPointAgglosMin);
+		}
+	}
+
 	sfRenderTexture_display(renderTexture);
 
 	/* Commenté car source de Segmentation Faults */
@@ -137,3 +159,61 @@ void afficherDateCurseur(const sfEvent *const event, sfRenderTexture *const rend
 		}
 	}
 }
+
+
+void afficherCoordonneesPoint(sfRenderWindow *const window, sfEvent *event, sfRenderTexture *const renderTexture, sfSprite **renderSprite, const uint32_t nbPointsAffiches, sfCircleShape *tabPointeursCercles[nbPointsAffiches], char **tabDatesConverties, uint32_t pointSuppr[nbPointsAffiches], uint32_t *nbPointSuppr, const sfFont *font)
+{
+	for(uint32_t i = 0; i < nbPointsAffiches; i++)
+	{
+		sfVector2f positionCercle = sfCircleShape_getPosition(tabPointeursCercles[i]);
+		
+		if(mouseIsInCircle((sfVector2f){event->mouseMove.x - CIRCLERADIUS, event->mouseMove.y - CIRCLERADIUS}, (Cercle){positionCercle, CIRCLERADIUS}))
+		{
+			sfText *texte = creerTexte((sfVector2f){positionCercle.x + OFFSETFORDATE, positionCercle.y - OFFSETFORDATE}, tabDatesConverties[i], font, 20, sfBlack);
+			sfRenderTexture_drawText(renderTexture, texte, NULL);
+			*renderSprite = loadSpriteFromRenderTexture(renderTexture);
+			sfText_destroy(texte);
+			sfRenderWindow_waitEvent(window, event);
+
+			if(event->type == sfEvtMouseButtonPressed && sfMouse_isButtonPressed(sfMouseRight))
+			{
+				printf("Point numéro : %d\n", i);
+
+				if(!pointDejaSelectionne(*nbPointSuppr, pointSuppr, i))
+				{
+					pointSuppr[*nbPointSuppr] = i;
+					*nbPointSuppr += 1;
+				}
+			}
+
+			break;
+		}
+	}
+}
+
+
+void selectionnerAgglomerats(sfRenderWindow *const window, sfEvent *event, const uint32_t nbAgglos, sfCircleShape *tabPointeursCerclesAgglos[nbAgglos],AgglomeratConverti *agglos, uint32_t agglosSuppr[nbAgglos], uint32_t *nbAgglosSuppr)
+{
+	for(uint32_t i = 0; i < nbAgglos; i++)
+	{
+		sfVector2f positionCercle = sfCircleShape_getPosition(tabPointeursCerclesAgglos[i]);
+		
+		if(mouseIsInCircle((sfVector2f){event->mouseMove.x - agglos[i].tailleCercle, event->mouseMove.y - agglos[i].tailleCercle}, (Cercle){positionCercle,agglos[i].tailleCercle}))
+		{
+			sfRenderWindow_waitEvent(window, event);
+
+			if(event->type == sfEvtMouseButtonPressed && sfMouse_isButtonPressed(sfMouseRight))
+			{
+				printf("Point agglos numéro : %d\n", i);
+
+				if(!pointDejaSelectionne(*nbAgglosSuppr, agglosSuppr, i))
+				{
+					agglosSuppr[*nbAgglosSuppr] = i;
+					*nbAgglosSuppr += 1;
+				}
+			}
+
+			break;
+		}
+	}
+}

Controleur/controleAffichage.h

@@ -30,7 +30,7 @@ void affichageMenuContinu(sfRenderWindow *const window, sfRenderTexture *renderT
  * @param mode Mode dans lequel on effectue l'affichage !
  * @return Le nombre de points correctement affichés.
 */
-uint32_t affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderTexture, sfSprite *renderSprite, PointConverti *tabPointsConvertis,  uint32_t nbElements, sfCircleShape *tabPointeursCercle[nbElements], const Mode mode);
+uint32_t affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderTexture, sfSprite *renderSprite, PointConverti *tabPointConvertis, Point *tabPoint, uint32_t nbElements, uint32_t  *nbPointsAffiches, uint32_t nbPointAgglosMin, sfCircleShape *tabPointeursCercle[nbElements], AgglomeratConverti *agglos, uint32_t nbAgglos, sfCircleShape *tabPointeursCercleAgglos[nbAgglos], const Mode mode);
 
 /**
  * @brief Si le curseur est positionné sur un point affiché, on écrit la date à côté.
@@ -48,3 +48,9 @@ uint32_t affichageLogs(sfRenderWindow *const window, sfRenderTexture *renderText
  * @return Procédure.
 */
 void afficherDateCurseur(const sfEvent *const event, sfRenderTexture *const renderTexture, sfSprite **renderSprite, const uint32_t nbPointsAffiches, sfCircleShape *tabPointeursCercles[nbPointsAffiches], char **tabDatesConverties, const sfFont *font);
+
+/* TO DO (+ revoir documentation d'affichageLogs() en même temps */
+void afficherCoordonneesPoint(sfRenderWindow *const window, sfEvent *event, sfRenderTexture *const renderTexture, sfSprite **renderSprite, const uint32_t nbPointsAffiches, sfCircleShape *tabPointeursCercles[nbPointsAffiches], char **tabDatesConverties, uint32_t pointSuppr[nbPointsAffiches], uint32_t *nbPointSuppr, const sfFont *font);
+
+/* TO DO (+ revoir documentation d'affichageLogs() en même temps */
+void selectionnerAgglomerats(sfRenderWindow *const window, sfEvent *event, const uint32_t nbAgglos, sfCircleShape *tabPointeursCerclesAgglos[nbAgglos],AgglomeratConverti *agglos, uint32_t agglosSuppr[nbAgglos], uint32_t *nbAgglosSuppr);

Controleur/controleur.c

@@ -17,7 +17,14 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 
 	uint32_t nbElements;
 
-	Point *tabPoints = NULL;
+	uint32_t nbAgglos         = 0;
+	uint32_t nbPointAgglosMin = 0;
+	uint32_t nbPointSuppr     = 0;
+	uint32_t nbAgglosSuppr    = 0;
+	Agglomerat *agglos        = NULL;
+
+	Point *tabPoints                  = NULL;
+	AgglomeratConverti *aggloConverti = NULL;
 	/* _________________________________________________________ */
 
 	// On vient lire les logs de géolocalisation
@@ -27,6 +34,9 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 		return result;
 	}
 
+	// On repère les agglomérats !
+	repereAgglo(tabPoints, nbElements, &agglos, &nbAgglos);
+
 	// On lance la procédure de conversion des dates
 	char **tabDateConverties = conversionDates(tabPoints, nbElements);
 	if(tabDateConverties == NULL)
@@ -34,8 +44,9 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 		return ALLOCATION_FAILURE;
 	}
 
-	// Un petit tableau pour sauvegarder l'adresse des points affichés en mémoire
+	// Deux petits tableaux pour sauvegarder l'adresse des points et agglomérats affichés en mémoire
 	sfCircleShape *tabPointeursCercle[nbElements];
+	sfCircleShape *tabPointeursCercleAgglos[nbAgglos];
 
 	// Ce tableau contiendra de façon successive les coordonnées converties en nombre de pixels des points à afficher
 	PointConverti *tabPointsConvertis = NULL;
@@ -43,7 +54,9 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 	// Des variables en vrac pour les différents futurs calculs / opérations
 	sfEvent event;
 	Action action = NOACTION;
-	uint32_t nbPointsAffiches, nbPointsSouhaiter = nbElements;
+	uint32_t nbPointsAffiches = 0, nbPointsSouhaiter = nbElements;
+
+	uint32_t agglosSuppr[nbAgglos];
 
 	Carte carte;
 	initialiserCarte(&carte);
@@ -97,6 +110,14 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 			break;
 		}
 
+		// On convertit les agglos en coordonnées cartésiennes !
+		aggloConverti = conversionAgglos(agglos, nbAgglos, &carte.pointCentral, carte.echelle);
+		if(aggloConverti == NULL)
+		{
+			flag = ALLOCATION_FAILURE;
+			break;
+		}
+
 		// On affiche la carte !
 		afficherCarte(renderTexture, &carte.mapTexture, &carte.mapSprite, MAPFILE);
 
@@ -104,7 +125,63 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 
 		if(mode == GLOBAL || mode == PBP_AUTOMATIC || mode == PBP_MANUAL)
 		{
-			nbPointsAffiches = affichageLogs(window, renderTexture, renderSprite, tabPointsConvertis, nbPointsSouhaiter, tabPointeursCercle, mode);
+			nbPointAgglosMin = getMinAgglo(agglos, nbAgglos);
+
+			nbPointsAffiches = affichageLogs(window, renderTexture, renderSprite, tabPointsConvertis, tabPoints, nbPointsSouhaiter, &nbPointsAffiches, nbPointAgglosMin, tabPointeursCercle, aggloConverti, nbAgglos, tabPointeursCercleAgglos, mode);
+
+			// À DÉPLACER CAR PAS BEAU
+			uint32_t pointsSuppr[nbPointsAffiches];
+
+			// ÇA SERAIT COOL DE METTRE ÇA DANS UNE FONCTION À L'OCCAS'
+			// En fait il faut arriver à rendre compatible ma fonction d'attente avec ce qui est fait ici...
+			while(1)
+			{
+				sfTexture *originalTexture = sfTexture_copy(sfRenderTexture_getTexture(renderTexture));
+				while(sfRenderWindow_waitEvent(window, &event))
+				{
+					if(event.type == sfEvtClosed || (event.type == sfEvtKeyPressed && event.key.code == sfKeyEscape))
+					{
+						sfRenderWindow_close(window);
+						sfRenderWindow_destroy(window);
+
+						exit(EXIT_SUCCESS);
+					}
+
+					else if(event.type == sfEvtResized)
+					{
+						displayBackgroundSprite(window, renderSprite);
+					}
+
+					else if(event.type == sfEvtMouseMoved)
+					{
+						sfRenderTexture_clear(renderTexture, sfWhite);
+						renderSprite = loadSpriteFromTexture((sfVector2f){0.0, 0.0}, originalTexture);
+						sfRenderTexture_drawSprite(renderTexture, renderSprite, NULL);
+
+						afficherCoordonneesPoint(window, &event, renderTexture, &renderSprite, nbPointsAffiches, tabPointeursCercle, tabDateConverties, pointsSuppr, &nbPointSuppr, font);
+
+						displayBackgroundSprite(window, renderSprite);
+						selectionnerAgglomerats(window, &event, nbAgglos, tabPointeursCercleAgglos, aggloConverti, agglosSuppr, &nbAgglosSuppr);
+						ordonnerTableau(nbPointSuppr, pointsSuppr);
+						ordonnerTableau(nbAgglosSuppr, agglosSuppr);
+					}
+
+					// Cette condition ne restera pas, c'est juste un test pour voir si le tableau se remplit bien !
+					else if((event.type == sfEvtKeyPressed) && (event.key.code == sfKeyT))
+					{
+						printf("Il y a %u points à supprimer, dont la liste est : \n", nbPointSuppr);
+						for(uint32_t i=0;i < nbPointSuppr; i++)
+						{
+							printf("Le point %d est a supprimer \n", pointsSuppr[i]);
+						}
+						printf("Il y a %u agglos à supprimer, dont la liste est : \n", nbAgglosSuppr);
+						for(uint32_t i=0;i < nbAgglosSuppr; i++)
+						{
+							printf("L'agglo %d est a supprimer \n",agglosSuppr[i]);
+						}
+					}
+				}
+			}
 		}
 
 		else
@@ -130,7 +207,7 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 			case ZOOM_NEXT:
 				// L'utilisateur a effectué un zoom sur la carte (et il est autorisé à le faire)
 				// --> 0n libère la mémoire des éléments actuellement affichés, et on re-boucle !
-				libererMemoireElementsAffiches(&carte, MAPFILE, tabPointsConvertis, nbPointsAffiches, tabPointeursCercle);
+				libererMemoireElementsAffiches(&carte, MAPFILE, tabPointsConvertis, aggloConverti, nbPointsAffiches, tabPointeursCercle);
 
 				// On convertit les pixels retournés en coordonnées géograpiques...
 				conversionRec(&carre, &carte.pointHautGauche, &carte.pointBasDroite, &carte.pointCentral, carte.echelle);
@@ -169,11 +246,12 @@ ErrEnum controlePoints(sfRenderWindow *window, const char *cheminFichier, Mode m
 
 	} while(keepGoing); // Ceci est bien entendu une fausse boucle infinie (cf. le test juste ci-dessus...)
 
-	libererMemoireElementsAffiches(&carte, MAPFILE, tabPointsConvertis, nbPointsAffiches, tabPointeursCercle);
+	libererMemoireElementsAffiches(&carte, MAPFILE, tabPointsConvertis, aggloConverti, nbPointsAffiches, tabPointeursCercle);
 
 	sfFont_destroy(font);
 	free(tabPoints);
+	free(agglos);
 	freeTabGeneric((void***)&tabDateConverties, nbElements);
 
 	return flag;
-}
+}

Controleur/controleur.h

@@ -12,6 +12,7 @@
 
 #include "../Modele/load.h"
 #include "../Modele/calcul.h"
+#include "../Modele/agglo.h"
 #include "../Vue/vue.h"
 
 #include "conversion.h"
@@ -22,6 +23,7 @@
 #include "carte.h"
 
 
+
 /**
  * @brief Gère l'ouverture, l'appel à l'affichage, et la suppression des logs dans un fichier.
  *

Controleur/conversion.c

@@ -46,6 +46,29 @@ PointConverti* conversionPoints(Point *tabInitial, uint32_t nbElements, const Co
 	return tabConverti;
 }
 
+AgglomeratConverti* conversionAgglos(Agglomerat *aggloInitial, uint32_t nbAgglos, const Coordonnees *const pointCentral, const double echelle)
+{
+	AgglomeratConverti *aggloConverti = calloc(nbAgglos, sizeof(*aggloConverti));
+	if(aggloConverti == NULL)
+	{
+		fprintf(stderr, "%s\n", strerror(errno));
+		return NULL;
+	}
+	// Un ratio pour passer des distances (en mètres) à des pixels sur l'écran !
+	const double ratio = (1.0e2 * PPCM) / echelle;
+	for(uint32_t i = 0; i < nbAgglos; i++)
+	{
+		aggloConverti[i].moy.x = (ratio * RAYON * RADIANS(aggloInitial[i].moy.lon - pointCentral->lon) + (MAPSIZE * MAPSCALE) / 2.0) * WIDTH / (float)(MAPSIZE * MAPSCALE);
+		aggloConverti[i].moy.y = (ratio * RAYON * log(tan(PI / 4.0 + RADIANS(pointCentral->lat) / 2.0) / tan(PI / 4.0 + RADIANS(aggloInitial[i].moy.lat) / 2.0)) + (MAPSIZE * MAPSCALE) / 2.0) * HEIGHT / (float)(MAPSIZE * MAPSCALE);
+		aggloConverti[i].nbPts = aggloInitial[i].nbPts;
+		aggloConverti[i].rayon = aggloInitial[i].rayon;
+		aggloConverti[i].agglo = aggloInitial[i].agglo;
+		aggloConverti[i].ptRoute = aggloInitial[i].ptRoute;
+
+	}
+	return aggloConverti;
+}
+
 
 void conversionRec(const Rectangle *const rec, Coordonnees *const hg, Coordonnees *const bd, const Coordonnees *const pointCentral, const double echelle)
 {

Controleur/conversion.h

@@ -37,6 +37,7 @@ void conversionPixelsCoordonnees(Coordonnees *const destinationGPS, const sfVect
  *
  * @param tabInitial Tableau de pointeurs sur structure 'Point', à convertir.
  * @param nbElements Nombre de points à convertir.
+ * @param pointCentral Coordonnées du points central de la carte affichee a l'ecran
  * @param echelle Échelle de la carte adoptée !
  * @return Un tableau de points convertis.
 */
@@ -54,6 +55,17 @@ PointConverti* conversionPoints(Point *tabInitial, uint32_t nbElements, const Co
  */
 void conversionRec(const Rectangle *const rec, Coordonnees *const hg, Coordonnees *const bd,const Coordonnees *const pointCentral, const double echelle);
 
+/*
+ * @brief Convertit des points d'agglos de longitude / latitude vers des coordonnees cartesiennes.
+ * 
+ * @param aggloInital Tableau des agglos a convertir.
+ * @param nbAgglos Nombre d'agglos a convertir.
+ * @param pointCentral Coordonnées du points central de la carte affichee a l'ecran
+ * @param echelle Échelle de la carte adoptée
+ *@return Un tableau d'agglos de coordonnees cartesiennes
+*/
+AgglomeratConverti* conversionAgglos(Agglomerat *aggloInitial, uint32_t nbAgglos, const Coordonnees *const pointCentral, const double echelle);
+
 /**
  * @brief Convertit les dates codées (en nombre de secondes depuis 'Epoch') en chaînes de caractères lisibles.
  *

Controleur/destruction.c

@@ -36,7 +36,7 @@ void cleaningFunction(void)
 }
 
 
-void libererMemoireElementsAffiches(Carte *const carte, const char *const cheminFichier, PointConverti *tabPointsConvertis, uint32_t nbPointsAffiches, sfCircleShape *tabPointeursCercle[nbPointsAffiches])
+void libererMemoireElementsAffiches(Carte *const carte, const char *const cheminFichier, PointConverti *tabPointsConvertis, AgglomeratConverti *aggloConverti, uint32_t nbPointsAffiches, sfCircleShape *tabPointeursCercle[nbPointsAffiches])
 {
 	// Si cette texture n'est pas nulle, c'est que l'utilisateur a affiché des points. Libérons la mémoire !
 	if(carte->mapTexture != NULL)
@@ -50,5 +50,6 @@ void libererMemoireElementsAffiches(Carte *const carte, const char *const chemin
 
 		detruireCercles(nbPointsAffiches, tabPointeursCercle);
 		free(tabPointsConvertis);
+		free(aggloConverti);
 	}
 }

Controleur/destruction.h

@@ -34,8 +34,9 @@ void cleaningFunction(void);
  * @param carte Un pointeur sur une carte dont la mémoire est à supprimer !
  * @param cheminFichier Chemin relatif du fichier contenant la carte.
  * @param tabPointsConvertis Tableau contenant les coordonnées converties des points.
+ * @param aggloConverti Tableau contenant les coordonnées converties des agglomérats.
  * @param nbPointsAffiches Nombre de points affichés sur la carte.
  * @param tabPointeursCercle Tableau de pointeurs sur les cercles affichés.
  * @return Procédure.
 */
-void libererMemoireElementsAffiches(Carte *const carte, const char *const cheminFichier, PointConverti *tabPointsConvertis, uint32_t nbPointsAffiches, sfCircleShape *tabPointeursCercle[nbPointsAffiches]);
+void libererMemoireElementsAffiches(Carte *const carte, const char *const cheminFichier, PointConverti *tabPointsConvertis, AgglomeratConverti *aggloConverti, uint32_t nbPointsAffiches, sfCircleShape *tabPointeursCercle[nbPointsAffiches]);

Controleur/miscellaneous.c

@@ -119,3 +119,52 @@ void getZoomEchelle(Carte *const carte)
 	// L'échelle de la carte avec le zoom arrondi.
 	carte->echelle = getEchelleFromZoom(carte->zoom);
 }
+
+
+uint32_t getMinAgglo(Agglomerat *agglos, uint32_t nbAgglos)
+{
+	uint32_t nbPointsAggloMin;
+	if (nbAgglos > 0)
+	{
+		nbPointsAggloMin = agglos[0].nbPts;
+		for(uint32_t i = 0; i < nbAgglos; i++)
+		{
+			if(agglos[i].nbPts < nbPointsAggloMin)
+			{
+				nbPointsAggloMin = agglos[i].nbPts;
+			}
+		}
+	}
+	return nbPointsAggloMin;
+}
+
+
+uint32_t pointDejaSelectionne(uint32_t nbElement, uint32_t tab[nbElement], uint32_t valeur)
+{
+	for(uint32_t i = 0; i < nbElement; i++)
+	{
+		if(tab[i] == valeur)
+		{
+			return 1;
+		}
+	}
+	return 0;
+}
+
+void ordonnerTableau(uint32_t nbElement, uint32_t tab[nbElement])
+{
+    uint32_t i,j,tmp;
+    for(i=0; i<nbElement; i++)
+    {
+   		for(j=i+1; j<nbElement; j++) 
+   		{
+    		if(tab[i]>tab[j]) 
+    		{
+        		tmp = tab[i];
+        		tab[i] = tab[j];
+        		tab[j] = tmp;     
+      		}
+   		}
+   	}
+}
+ 

Controleur/miscellaneous.h

@@ -63,3 +63,31 @@ double getEchelleFromZoom(const uint8_t zoom);
  * @return Procédure.
 */
 void getZoomEchelle(Carte *const carte);
+
+/**
+ * @brief fonction qui renvoie le nombre minimal de points dans une agglo.
+ *
+ * @param agglos Tableau d'agglos ou on va verifier le nombre de point contenu
+ * @param nbAgglos Taille du tableau d'agglos
+ * @return nombre minimal de points dans une agglo
+*/
+uint32_t getMinAgglo(Agglomerat *agglos, uint32_t nbAgglos);
+
+/**
+ * @brief Fonction qui verifie qu'un point selectionné n'ait pas déjà été séléctionné.
+ *
+ * @param nbElement Nombre d'éléments du tableau des points déjà selectionnés.
+ * @param tab Tableau des points déjà selectionnés.
+ * @param valeur Numéro du point selectionné.
+ * @return 1 si le point y est déjà, 0 sinon.
+*/
+uint32_t pointDejaSelectionne(uint32_t nbElement, uint32_t tab[nbElement], uint32_t valeur);
+
+/*
+ * @brief Fonction qui va ordonner le tableau des points selectionnés.
+ *
+ * @param nbElement Nombre d'éléments du tableau des points déjà selectionnés.
+ * @param tab Tableau des points déjà selectionnés.
+ * @return Procédure.
+*/
+void ordonnerTableau(uint32_t nbElement, uint32_t tab[nbElement]);

Headers/constantes.h

@@ -2,7 +2,7 @@
 
 
 // Modèle
-/* ... */
+#define AGGLOROUTEDISTANCE 100.0 //Distance tolérée avant de délier une rotue d'un agglomérat. #misAuPif
 
 
 // Contrôleur
@@ -35,6 +35,7 @@
 
 // Rayon des points dessinés (en pixels) !
 #define CIRCLERADIUS 2
+#define CIRCLERADIUSAGGLO 5
 
 // Bordure en plus à prendre en compte quand on récupère une carte (afin d'intégrer des points potentiellement sur un des côtés...) [en pixels]
 #define BORDERSIZE 25

Headers/structures.h

@@ -9,6 +9,7 @@
 
 
 typedef struct Agglomerat Agglomerat;
+typedef struct AgglomeratConverti AgglomeratConverti;
 typedef struct Route Route;
 typedef struct Intersection Intersection;
 
@@ -46,8 +47,20 @@ struct Agglomerat
 	uint32_t nbPts;
 	Route **ptRoute;
 	double rayon;
+	double tailleCercle;
 };
 
+struct AgglomeratConverti
+{
+	sfVector2f moy;
+	Point **agglo;
+	uint32_t nbPts;
+	Route **ptRoute;
+	double rayon;
+	double tailleCercle;
+};
+
+
 struct Route
 {
 	Point **chemin;

Modele/agglo.c

@@ -16,6 +16,7 @@ ErrEnum initAgglo(Agglomerat* a,Point* pts, uint32_t taille)
 	a->moy.lon=0;
 	for (uint32_t i=0; i<taille;i++)
 	{
+		pts[i].type=AGGLOMERAT;
 		a->agglo[i]=&pts[i];
 		a->moy.lat+=pts[i].pos.lat;
 		a->moy.lon+=pts[i].pos.lon;
@@ -35,8 +36,9 @@ void libereAgglo(Agglomerat *const a)
 
 Agglomerat fusionAgglo(Agglomerat const*  const a1, Agglomerat const*  const a2)
 {
+	/*Pour que les agglomérats soient dans l'ordre chronologique*/
 	if (a1->agglo[0]->date > a2->agglo[0]->date)
-		return fusionAgglo(a2,a1);
+		return fusionAgglo(a2,a1); 
 
 
 	Agglomerat retour;
@@ -49,10 +51,14 @@ Agglomerat fusionAgglo(Agglomerat const*  const a1, Agglomerat const*  const a2)
 		return (Agglomerat){ {0, 0}, NULL, 0};
 	}
 
+	/*Définition des valeurs du nouvel agglomérat*/
+
 	retour.nbPts=a1->nbPts+a2->nbPts;
 	retour.moy.lat=(a1->moy.lat+a2->moy.lat)/2;
 	retour.moy.lon=(a1->moy.lon+a2->moy.lon)/2;
 
+	/*Concaténation des points dans le nouvel agglomérat*/
+
 	for(uint32_t i=0; i<a1->nbPts;i++)
 	{
 		retour.agglo[i]=a1->agglo[i]; 
@@ -72,3 +78,130 @@ uint32_t ecartTemps(Agglomerat const* const a1, Agglomerat const* const a2)
 
 	return a2->agglo[0]->date - a1->agglo[a1->nbPts -1]->date;
 }
+
+ErrEnum repereAgglo(Point* points, uint32_t tailleP, Agglomerat** agglos, uint32_t* tailleA)
+{
+	uint32_t periode=points[1].date - points[0].date;
+	*tailleA=0;
+	Agglomerat** agglosTmp=calloc(tailleP/2, sizeof(Agglomerat*));
+	if (agglosTmp==NULL)
+	{
+		fprintf(stderr, "%s\n", strerror(errno));
+		return ALLOCATION_FAILURE;
+	}
+	Agglomerat* tmp=NULL,* entre=NULL,*fusionIntermediaire=NULL;
+	uint32_t debut,fin,finPrec,t;
+
+	for(uint32_t i=1; i<tailleP; i++)
+	{
+		/*debut et fin représentent les index entre lesquels sont compris les
+		 points du potentiel futur agglomérat*/
+		debut=i-1;
+		fin=i;
+
+		while(fin<tailleP &&
+			distance(&(points[fin].pos),&(points[fin-1].pos)) / periode <= VMIN*MARGE) 
+		/*Tant que la personne n'est pas en dessous d'une certaine vitesse
+		 (et qu'on est pas à la	fin du tableau) */
+		{
+			fin++;
+		}
+		if ((fin-debut)*periode>=DUREEMINI) 		
+		/*Si les points couvrent plus que la durée minimum d'un agglomérat
+		on crée un agglomérat à partir de ces points*/
+		{
+			t=*tailleA;
+
+			if ((agglosTmp[t]=calloc(1, sizeof(Agglomerat)))==NULL)
+			{
+				fprintf(stderr, "%s\n", strerror(errno));
+				return ALLOCATION_FAILURE;
+			}
+
+			if(initAgglo(agglosTmp[t], points + debut,fin-debut)==ALLOCATION_FAILURE)
+			{
+				return ALLOCATION_FAILURE;
+			}
+
+			if(t!=0 && (ecartTemps(agglosTmp[t-1],agglosTmp[t])<DIFTMINI
+				|| distance(&agglosTmp[t]->moy, &agglosTmp[t-1]->moy)<DISTMINI)) 
+			/*Si l'agglomérat construit est proche en distance ou en temps de l'agglomérat
+			précédent on les fusionne*/
+			{
+				if ((tmp=calloc(1,sizeof(Agglomerat)))==NULL)
+				{
+					fprintf(stderr, "%s\n", strerror(errno));
+					return ALLOCATION_FAILURE;
+				}
+				if (debut-finPrec>0)
+				{
+					/*On inclut les points entre les deux agglomérats dans la fusion.
+					  Pour cela, on créée un troisième agglomérat contenant ces points
+					  et on fusionne cet agglomérat avec les autres ensuite*/
+					if ((entre=calloc(1,sizeof(Agglomerat)))==NULL)
+					{
+						fprintf(stderr, "%s\n", strerror(errno));
+						return ALLOCATION_FAILURE;
+					}
+
+					if(initAgglo(entre,points+finPrec,debut-finPrec)==ALLOCATION_FAILURE)
+					{
+						return ALLOCATION_FAILURE;
+					}
+
+					if ((fusionIntermediaire=calloc(1,sizeof(Agglomerat)))==NULL)
+					{
+						fprintf(stderr, "%s\n", strerror(errno));
+						return ALLOCATION_FAILURE;
+					}
+
+					/*Fusionne les trois agglomérats agglosTmp[t-1] agglosTmp[t] et entre*/
+					*fusionIntermediaire=fusionAgglo(agglosTmp[t-1],entre);
+					*tmp=fusionAgglo(fusionIntermediaire,agglosTmp[t]);
+					if (fusionIntermediaire->nbPts==0 || tmp->nbPts==0)
+					{
+						return ALLOCATION_FAILURE;
+					}
+
+					libereAgglo(fusionIntermediaire);
+					libereAgglo(entre);
+					free(fusionIntermediaire);
+					free(entre);
+				}
+				else
+				{
+					*tmp=fusionAgglo(agglosTmp[t-1],agglosTmp[t]);
+				}
+
+				libereAgglo(agglosTmp[t-1]);
+				libereAgglo(agglosTmp[t]);
+				free(agglosTmp[t-1]);
+				free(agglosTmp[t]);
+
+				agglosTmp[t]=NULL;
+				agglosTmp[t-1]=tmp;
+				tmp=NULL;
+			}
+			else
+			{
+				(*tailleA)++;
+			}
+			finPrec=fin;
+		}
+		i=fin;
+	}
+
+	if ((*agglos=calloc(*tailleA, sizeof(Agglomerat)))==NULL)
+	{
+		fprintf(stderr, "%s\n", strerror(errno));
+		return ALLOCATION_FAILURE;
+	}
+
+	for(uint32_t i=0; i<*tailleA; i++)
+	{
+		agglos[0][i]=*agglosTmp[i];
+		free(agglosTmp[i]);
+	}
+	free(agglosTmp);
+	return SUCCESS;
+}

Modele/agglo.h

@@ -28,7 +28,7 @@ d'écarter les cas où la personne ralentit pour une raison quelconque*/
 *
 * @return Retourne une valeur d'erreur définie dans 'strucutres.h' 
 */
-ErrEnum initAgglo(Agglomerat*,Point* ,uint32_t);
+ErrEnum initAgglo(Agglomerat* a,Point* pts, uint32_t taille);
 
 /**
 * @brief Libère la mémoire prise par le tableau de pointeurs sur points de 
@@ -36,9 +36,9 @@ ErrEnum initAgglo(Agglomerat*,Point* ,uint32_t);
 *
 * @param a L'agglomérat où on libère la mémoire
 * 
-* @return Procédure
+* @return Valeur d'erreur ou de succes définies dans structures.h
 */
-void libereAgglo(Agglomerat *const);
+void libereAgglo(Agglomerat *const a);
 
 /**
 * @brief Fusionne deux agglomérats
@@ -52,7 +52,7 @@ void libereAgglo(Agglomerat *const);
 * @return Résultat de la fusion des deux agglomérat. La structure est remplie de 0
 * en cas d'échec.
 */
-Agglomerat fusionAgglo(Agglomerat const* const, Agglomerat const* const);
+Agglomerat fusionAgglo(Agglomerat const*  const a1, Agglomerat const*  const a2);
 
 /**
 * @brief Retourne l'écart de temps entre les deux agglomérats 
@@ -65,5 +65,17 @@ Agglomerat fusionAgglo(Agglomerat const* const, Agglomerat const* const);
 *
 * @return L'écart de temps entre les deux agglomérats
 */
-uint32_t ecartTemps(Agglomerat const* const, Agglomerat const* const);
-ErrEnum repereAgglo(Point*, uint32_t, Agglomerat**, uint32_t*);
+uint32_t ecartTemps(Agglomerat const* const a1, Agglomerat const* const a2);
+
+/*
+ * @brief Repère les agglomérats  à partir d'un tableau de points 
+ *
+ * @param points Tableau de points servant au repérage des agglomérats 
+ * @param tailleP Taille du tableau de points 
+ * @param agglos Adresse du tableau qui contiendra les agglomérats repérés
+ * @param tailleA Adresse de la variable qui contiendra la taille du tableau d'agglomérats
+ *
+ * @return Valeur d'erreur ou de succes définies dans structures.h
+ */
+ErrEnum repereAgglo(Point* points, uint32_t tailleP, Agglomerat** agglos, uint32_t* tailleA);
+

Modele/calcul.h

@@ -13,7 +13,7 @@
 *
 * @param a Premier argument de l'opération
 * @param b Premier argument de l'opération
-* @return Retourne la distance entre les deux coordonnees 
+* @return Retourne la distance entre les deux coordonnees en mètres
 */
 double distance(Coordonnees const* const, Coordonnees const* const);
 

Modele/route.c

@@ -0,0 +1,103 @@
+#include "route.h"
+
+ErrEnum repereRoute(Point *tabPoint, const uint32_t tailleP, Agglomerat *tabAgglo, const uint32_t tailleA, Route **tabRoute, uint32_t *tailleR)
+{
+	uint32_t numRoute = 0, i = 0;
+
+	Route *tmp = calloc(tailleP/2, sizeof(Route)); //Arbitraiement, on considère le nombre de routes MAX tailleP/2
+	if(tmp == NULL)
+	{
+		fprintf(stderr, "%s\n", strerror(errno));
+		return ALLOCATION_FAILURE;
+	}
+
+	while(i < tailleP)
+	{
+		if(tabPoint[i].type == NONE) //Si point à NONE c'est que pas agglomérat : donc route
+		{
+			uint32_t debutRoute = i;
+			while(tabPoint[i].type == NONE && i < tailleP) //On compte combien de points vont constituer cette route
+				++i;
+
+			tmp[numRoute].chemin = calloc(i-debutRoute, sizeof(Point*)); //Allocation du chemin
+			if(tmp[numRoute].chemin == NULL)
+			{
+				fprintf(stderr, "%s\n", strerror(errno));
+				return ALLOCATION_FAILURE;
+			}
+
+			for(uint32_t k = debutRoute, j = 0; k < i; ++k, ++j)
+			{
+				tmp[numRoute].chemin[j] = &tabPoint[k];
+				tabPoint[k].type = ROUTE;
+			}
+			tmp[numRoute].nbPts = i-debutRoute;
+			
+			//Rempli le champ ptAgglo[]
+			pointageSurAgglo(&tmp[numRoute], tabPoint, tailleP, tabAgglo, tailleA, debutRoute, i-1);
+
+			++numRoute;
+		}
+		else
+			++i;
+	}
+
+	/*Allocation final, avec le bon nombre de route*/
+	*tailleR = numRoute;
+	*tabRoute = realloc(tmp, *tailleR*sizeof(Route)); //Le free est fait automatiquement grâce au realloc
+	if(*tabRoute == NULL)
+	{
+		fprintf(stderr, "%s\n", strerror(errno));
+		return ALLOCATION_FAILURE;
+	}
+	return SUCCESS;
+
+		/********TODO*******/
+	/*Je ne repère pas encore si y a 'Route' 'SAUT' 'autre Route'.*/
+	/*Ca sera considéré comme une seule route pour le moment.*/
+}
+
+void pointageSurAgglo(Route *tmp, const Point *tabPoint, const uint32_t tailleP, Agglomerat *tabAgglo, const uint32_t tailleA, const uint32_t debutRoute, const uint32_t finRoute)
+{
+		tmp->ptAgglo[0] = NULL;
+		tmp->ptAgglo[1] = NULL;
+
+		if(debutRoute != 0)
+		{
+			Coordonnees cooAg = tabPoint[debutRoute-1].pos;
+			Coordonnees cooRo = tabPoint[debutRoute].pos;
+
+			if(tabPoint[debutRoute-1].type != ROUTE && distance(&cooAg, &cooRo) <= AGGLOROUTEDISTANCE)
+			{
+				for(uint32_t i = 0; i < tailleA; ++i)
+				{
+					if(&tabPoint[debutRoute-1] == tabAgglo[i].agglo[tabAgglo[i].nbPts-1])
+					{
+						printf("Liaison début effectuée entre route[%p] et agglo[%p]\n", tmp, &tabAgglo[i]);
+						tmp->ptAgglo[0] = &tabAgglo[i];
+						break;
+					}
+				}
+			}		
+		}
+
+		//Si le finRoute est le dernier point de la liste alors finRoute+2 = tailleP
+		if(finRoute+2 != tailleP) 
+		{
+			Coordonnees cooRo = tabPoint[finRoute].pos;
+			Coordonnees cooAg = tabPoint[finRoute+1].pos;
+
+			if(tabPoint[finRoute+1].type != ROUTE && distance(&cooAg, &cooRo) <= AGGLOROUTEDISTANCE)
+			{
+				for(uint32_t i = 0; i < tailleA; ++i)
+				{
+					if(&tabPoint[finRoute+1] == tabAgglo[i].agglo[0])
+					{
+						printf("Liaison fin effectuée entre route[%p] et agglo[%p]\n", tmp, &tabAgglo[i]);
+						tmp->ptAgglo[1] = &tabAgglo[i];
+						break;
+					}
+				}
+			}
+		}
+}

Modele/route.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "calcul.h"
+#include "../Headers/structures.h"
+
+/**
+ * @brief Créer le tableau de route.
+ *
+ * Cette fonction traite le tableau de point pour regrouper en routes ceux qui doivent l'être.
+ * Marque par l'attribut ROUTE les points POINTES (pas de recopie, dépandance du tableau de points).
+ * Pointe les agglomérats début et fin de route. NULL si pas d'attache (fichier corrompu, saut).
+ *
+ * @param tabPoint Tableau de points général
+ * @param tailleP Taille du tableau de points général
+ * @param tabAgglo Tableau des agglomérats de points
+ * @param tailleA Taille du tableau d'agglomérats
+ * @param tabRoute Tableau de routes qui va être alloué et rempli dans cette fonction
+ * @param tailleR Taille du tableau de routes. Sera initialisé dans cette fonction.
+ * @return Retourne une valeur d'erreur définie dans 'structures.h'. SUCCESS en cas de réussite.
+*/
+
+ErrEnum repereRoute(Point *tabPoint, const uint32_t tailleP, Agglomerat *tabAgglo, const uint32_t tailleA, Route **tabRoute, uint32_t *tailleR);
+
+
+/**
+ * @brief Fait pointer les routes sur les agglomérats associés si cela est possible.
+ *
+ * Si aucun agglomérat n'est disponible (trop éloigné donc risque de saut, ou encore route
+ * en début et fin de fichier), met les pointeurs à NULL.
+ *
+ * @param tmp Route sur laquelle on travaille.
+ * @param tabPoint Tableau de points général
+ * @param tailleP Taille du tableau de points général
+ * @param tabAgglo Tableau des agglomérats de points
+ * @param tailleA Taille du tableau d'agglomérats
+ * @param debutRoute Contient l'indice du premier point de la route dans le tabPoint
+ * @param finRoute Contient l'indice du dernier point de la route dans le tabPoint
+ * @return void
+*/
+void pointageSurAgglo(Route *tmp, const Point *tabPoint, const uint32_t tailleP, Agglomerat *tabAgglo, const uint32_t tailleA, const uint32_t debutRoute, const uint32_t finRoute);

Vue/affichage.c

@@ -29,6 +29,53 @@ void afficherPoint(sfRenderTexture *const renderTexture, sfVector2f points, sfCi
 }
 
 
+void afficherAgglo(sfRenderTexture *const renderTexture, AgglomeratConverti *agglos, sfCircleShape **ptrCercle, uint32_t nbPointAgglosMin)	
+{
+	sfCircleShape *cercle = NULL;
+	if(agglos->nbPts <= nbPointAgglosMin * 1.5)
+	{	
+		cercle = creerCercle((sfVector2f){agglos->moy.x, agglos->moy.y}, CIRCLERADIUSAGGLO, sfBlue);
+		agglos->tailleCercle = CIRCLERADIUSAGGLO;
+	}
+
+	else
+	{
+		if(agglos->nbPts <= nbPointAgglosMin * 2)
+		{	
+			cercle = creerCercle((sfVector2f){agglos->moy.x, agglos->moy.y}, CIRCLERADIUSAGGLO * 1.5, sfBlue);
+			agglos->tailleCercle = CIRCLERADIUSAGGLO * 1.5;
+		}
+
+		else
+		{
+			if(agglos->nbPts <= nbPointAgglosMin * 2.5)
+			{	
+				cercle = creerCercle((sfVector2f){agglos->moy.x, agglos->moy.y}, CIRCLERADIUSAGGLO * 2, sfBlue);
+				agglos->tailleCercle = CIRCLERADIUSAGGLO * 2;
+			}
+
+			else
+			{
+				if(agglos->nbPts <= nbPointAgglosMin * 3)
+				{	
+					cercle = creerCercle((sfVector2f){agglos->moy.x, agglos->moy.y}, CIRCLERADIUSAGGLO * 2.5, sfBlue);
+					agglos->tailleCercle = CIRCLERADIUSAGGLO * 2.5;
+				}
+
+				else
+				{	
+					cercle = creerCercle((sfVector2f){agglos->moy.x, agglos->moy.y}, CIRCLERADIUSAGGLO * 3, sfBlue);
+					agglos->tailleCercle = CIRCLERADIUSAGGLO * 3;
+				}
+			}
+		}
+	}
+
+	sfRenderTexture_drawCircleShape(renderTexture, cercle, NULL);
+	*ptrCercle = cercle;
+}
+
+
 void afficherCarte(sfRenderTexture *const renderTexture, sfTexture **mapTexture, sfSprite **mapSprite, const char *const cheminFichier)
 {
 	*mapTexture = loadTextureFromFile(cheminFichier);

Vue/affichage.h

@@ -2,7 +2,6 @@
 
 #include "vue.h"
 
-
 /**
  * @brief Effectue toute la procédure d'affichage d'un sprite sur une fenêtre
  *
@@ -32,6 +31,17 @@ void clearDisplayBackground(sfRenderWindow *const window, sfRenderTexture *rende
 */
 void afficherPoint(sfRenderTexture *const renderTexture, sfVector2f points, sfCircleShape **ptrCercle);
 
+/**
+ * @brief Affiche un point d'interet plus ou moins gros en fonction du nombre de points qu'il contient
+ *
+ * @param renderTexture Texture dans laquelle on affiche le point d'interet.
+ * @parem agglos Point d'interet a afficher.
+ * @param ptrCercle Pointeur sur pointeur de type 'sfCircleShape', pour conserver son adresse une fois affiché.
+ * @param nbPointAggloMin Nombre de point minimal dans une agglo
+ * @return Procédure.
+*/
+void afficherAgglo(sfRenderTexture *const renderTexture, AgglomeratConverti *agglos, sfCircleShape **ptrCercle, uint32_t nbPointAgglosMin);
+
 /**
  * @brief Affiche une carte à partir d'une image et charge les pointeurs ad hoc !
  *

Vue/vue.h

@@ -1,12 +1,5 @@
 #pragma once
 
-
-
-
-
-
-
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
@@ -19,6 +12,7 @@
 
 #include "../Controleur/controleur.h"
 
+
 #include "affichage.h"
 #include "chargement.h"
 #include "creation.h"
@@ -49,4 +43,3 @@ void splashScreen(sfRenderWindow *window);
  * @return Procédure.
 */
 void handleMenu(sfRenderWindow *const window);
-