123 lines
3.5 KiB
C
123 lines
3.5 KiB
C
#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(i < tailleP && tabPoint[i].type == NONE) //On compte combien de points vont constituer cette route
|
|
{
|
|
if(i != tailleP-1 && tabPoint[i].type != AGGLOMERAT) //Si on est pas au dernier point et que le suivant ne fait pas parti d'un agglo
|
|
{
|
|
if(temps(tabPoint[i], tabPoint[i+1]) > TOLENTRESTRUCT) //ET que ce point et son suivant sont trop séparés temporellement
|
|
{
|
|
++i;
|
|
break; //Alors la route s'arrete ici. Et la suivante sera considéré comme une seconde route et pas 1 seule route avec un trou au milieu
|
|
}
|
|
}
|
|
++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[]. Première étape pour la suggestion de suppression.
|
|
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 && *tailleR != 0)
|
|
{
|
|
fprintf(stderr, "%s\n", strerror(errno));
|
|
return ALLOCATION_FAILURE;
|
|
}
|
|
|
|
/*Les points pointeront sur leur propre structure Route*/
|
|
for(uint32_t j = 0; j < *tailleR; ++j)
|
|
{
|
|
for(uint32_t k = 0; k < (*tabRoute)[j].nbPts; ++k)
|
|
{
|
|
(*tabRoute)[j].chemin[k]->ptOnStructure = (*tabRoute)+j;
|
|
}
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
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)
|
|
{
|
|
/*Si le point précédent le début de la route n'est effectivement pas une autre route
|
|
ET si le temps entre la fin de l'agglo et le début de la route n'est pas disproportionné (<= TOLENTRESTRUCT)*/
|
|
if(tabPoint[debutRoute-1].type != ROUTE && temps(tabPoint[debutRoute-1], tabPoint[debutRoute]) <= TOLENTRESTRUCT)
|
|
{
|
|
for(uint32_t i = 0; i < tailleA; ++i)
|
|
{
|
|
if(&tabPoint[debutRoute-1] == tabAgglo[i].agglo[tabAgglo[i].nbPts-1])
|
|
{
|
|
tmp->ptAgglo[0] = &tabAgglo[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Si le finRoute est le dernier point de la liste alors finRoute+1 = tailleP
|
|
if(finRoute+1 != tailleP)
|
|
{
|
|
if(tabPoint[finRoute+1].type != ROUTE && temps(tabPoint[debutRoute], tabPoint[debutRoute+1]) <= TOLENTRESTRUCT)
|
|
{
|
|
for(uint32_t i = 0; i < tailleA; ++i)
|
|
{
|
|
if(&tabPoint[finRoute+1] == tabAgglo[i].agglo[0])
|
|
{
|
|
tmp->ptAgglo[1] = &tabAgglo[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ErrEnum detruireTabRoute(Route *tabRoute, uint32_t tailleR)
|
|
{
|
|
for(uint32_t i = 0; i < tailleR; ++i)
|
|
free(tabRoute[i].chemin);
|
|
free(tabRoute);
|
|
|
|
return SUCCESS;
|
|
}
|