PDA

Visualizza la versione completa : [C] Funzioni di controllo spaziale


Mandibola
23-11-2010, 01:29
In pratica io ho il programma seguente (scusate ma non so come si scrive con i TAG) che deve prendere le dimensioni di un container, il numero di pacchi contenuti e le dimensioni dei pacchi contenuti e verificare se sbordano, se non si compenetrano e se sono stabili.
Il problema è che mi da sempre errore di compenetrazione anche quando non c'è.
Allego il file e alcuni esempi:



#include <stdio.h>
#include <stdlib.h>
#define MAX_PACCHI 100
#define MAX_VOL 100

struct coordinate
{
double x;
double y;
double z;
};

struct Pacco
{
struct coordinate posizione;
struct coordinate dimensioni;
}pacchi[MAX_PACCHI];

int WrongPosition (struct coordinate posizione, struct coordinate dimensioni, struct coordinate container);
int Compenetrazione (struct coordinate posizione, struct coordinate dimensioni);
int Stabilita (struct coordinate posizione, struct coordinate dimensioni);

int main(int argc, char *argv[])
{

long int TotalVolume=0;
long int i,j, numpacchi;
FILE *fp;
struct coordinate container;

if (argc!=2)
{
printf("\ne' necessario allegare 1 file.\n");
exit (EXIT_FAILURE);
}

if ((fp=fopen(argv[1],"r"))==NULL)
{
printf("\nil file non è stato trovato.\n");
exit (EXIT_FAILURE);
}
fscanf(fp,"%lf %lf %lf", &container.x, &container.y, &container.z);
fscanf(fp,"%ld", &numpacchi);
//Verifica che il volume totale non superi quello del container
for(i=0; i<numpacchi; i++)
{
fscanf(fp,"%lf %lf %lf", &pacchi[i].posizione.x, &pacchi[i].posizione.y, &pacchi[i].posizione.z);
fscanf(fp,"%lf %lf %lf", &pacchi[i].dimensioni.x, &pacchi[i].dimensioni.y, &pacchi[i].dimensioni.z);
TotalVolume += pacchi[i].dimensioni.x * pacchi[i].dimensioni.y * pacchi[i].dimensioni.z;

if (TotalVolume >= (container.x * container.y * container.z))
{
printf ("Container sottodimensionato.\n");
return -1;
}
;
if (WrongPosition(pacchi[i].posizione, pacchi[i].dimensioni, container))
{
printf ("Il pacco #%ld e' in posizione scorretta.\n", i);
return -1;
}

for (j=i+1; j<numpacchi; j++)
{
if (Compenetrazione(pacchi[MAX_PACCHI].posizione, pacchi[MAX_PACCHI].dimensioni))
{
printf ("Compenetrazione tra pacchi.\n");
return -1;
}
if (Stabilita(pacchi[MAX_PACCHI].posizione, pacchi[MAX_PACCHI].dimensioni))
{
printf ("Mancata stabilità tra pacchi.\n");
return -1;
}
}
}
return 0;
}

int WrongPosition (struct coordinate posizione, struct coordinate dimensioni, struct coordinate container)
{
if ((posizione.x + dimensioni.x > container.x) ||
(posizione.y + dimensioni.y > container.y) ||
(posizione.z + dimensioni.z > container.z))
{
return 1;
}
return 0;
}

int Compenetrazione (struct coordinate posizione, struct coordinate dimensioni)
{
int i = 0,j = 1;


if ((pacchi[j].posizione.x < (pacchi[i].posizione.x + pacchi[i].dimensioni.x)) && (pacchi[j].posizione.y < (pacchi[i].posizione.y + pacchi[i].dimensioni.y)))
{
return 1;
}

if ((pacchi[j].posizione.x < (pacchi[i].posizione.x + pacchi[i].dimensioni.x)) && (pacchi[j].posizione.z < (pacchi[i].posizione.z + pacchi[i].dimensioni.z)))
{
return 1;
}

if ((pacchi[j].posizione.z < (pacchi[i].posizione.z + pacchi[i].dimensioni.z)) && (pacchi[j].posizione.y < (pacchi[i].posizione.y + pacchi[i].dimensioni.y)))
{
return 1;
}
return 0;
}

int Stabilita (struct coordinate posizione, struct coordinate dimensioni)
{
long int i,j;

if ((pacchi[j].posizione.y == (pacchi[i].posizione.y + pacchi[i].dimensioni.y)))
{
if ((pacchi[j].dimensioni.z) * (pacchi[j].dimensioni.x) > (pacchi[i].dimensioni.z) * (pacchi[i].dimensioni.x))
{
return 1;
}
}
return 0;
}
]

MdE2005
25-11-2010, 07:17
Premesso che un minimo di commento del codice, quantomeno all'inizio di ogni procedura, faciliterebbe il nostro e quindi il tuo lavoro, per testare questo codice è necessario il file, cioè quello che passi come argomento.
Specifica poi i concetti di compenetrazione, stabilita e wrongposition perchè spesso per le variabili/funzioni si usano nomi non pertinenti.
Solo così potrò provare ad aiutarti.


Ciao :)

Andrea Simonassi
25-11-2010, 10:43
Intervengo solo per segnalarti che nella parte "Verifica che il volume totale non superi quello del container" c'è un errore:

il volume della somma dei pacchi può anche essere minore del volume del container ma i due pacchi potrebbero comunque non stare nel container (a meno che non siano liquidi a seconda della configurazione dei pacchi potrebbero rimanere degli spazi vuoti che devi considerare)

ciao


[CODE] esempio

*****
*****

[CODE]


ctr=5x2x1=10
p1 =4x1x1=4
p2 =2x2x1=4

p1+p2=8 che è <10 ma non possono stare contemporaneamente nel container.

Mandibola
25-11-2010, 14:29
Ciao,
intanto grazie dell'aiuto;
di seguito riporto esempi di file
e più precisamente:
Configurazione 1) ok
Configurazione 2) pacco 4 sborda perchè > container
Configurazione 3) dimensione pacco 1 > container
Configurazione 4) compenetrazione pacco 3 e 4
Configurazione 5) mancata stabilità pacco 4 e 5

conf.1


150.0 200.0 160.0

8

0.0 0.0 0.0
22.0 25.0 20.0

22.0 25.0 20.0
20.0 20.0 18.0

42.0 45.0 38.0
18.0 18.0 17.0

60.0 63.0 55.0
17.0 15.0 15.0

77.0 78.0 70.0
13.0 13.0 13.0

90.0 91.0 83.0
10.0 9.0 8.0

100.0 100.0 91.0
8.0 7.0 7.0

108.0 107.0 98.0
5.0 5.0 3.0



conf.2


100.0 90.0 50.0

5

0.0 0.0 0.0
22.0 14.0 20.0

22.0 14.0 20.0
18.0 13.0 12.0

40.0 27.0 32.0
17.0 12.0 11.0

57.0 39.0 43.0
16.0 10.0 9.0

73.0 49.0 52.0
15.0 8.0 7.0



conf.3


10.0 90.0 50.0

5

0.0 0.0 0.0
22.0 14.0 20.0

22.0 14.0 20.0
18.0 13.0 12.0

40.0 27.0 32.0
17.0 12.0 11.0

57.0 39.0 43.0
16.0 10.0 9.0

73.0 49.0 52.0
15.0 8.0 7.0


le altre non le riporto ma si è capito.
La funzione WrongPosition verifica che gli estremi dei pacchi non sbordino dal container;
ogni pacco viene identificato mediante le coordinate di posizione dell'angolo inferiore sx e le
dimensioni nelle tre direzioni (x,y,z);
la funzione compenetrazione verifica che i pacchi non siano uno all'interno dell'altro
o non abbiano zone in comune (io ho provato a farlo confrontando le dimensioni a due a due);
la funzione stabilità deve verificare che il pacco sotto abbia una superficie d'appoggio
maggiore di quello sopra.

Grazie

MdE2005
25-11-2010, 22:34
La tua procedura Compenetrazione ti ritorna sempre 0, giusto? Se è così l'errore è banale, vale a dire in fondo alla procedura ritorni il valore 0, a prescindere dalle tue if.
Fammi sapere se è questo il problema, altrimenti quando ho tempo (se lo trovo) dovrò analizzare tutto il codice.


Ciao :)

Mandibola
26-11-2010, 10:05
Ciao,
non proprio; se faccio girare i file in 4 casi su 5 (tranne quello in cui un pacco è in posizione scoretta) mi ritorna "compenetrazione tra pacchi" quindi c'è sempre return 1 nella funzione compenetrazione, penso sia li un errore. Cioè la funzione compenetrazione torna sempre 1

MdE2005
26-11-2010, 12:41
A livello di codice non ci sono errori, vale a dire che la funzione è impostata correttamente, così come il costrutto if: a questo punto dovresti, autonomamente, analizzare tutte le condizioni (magari con un output per controllare i valori); se non ci sono errori sarà sicuramente un problema di logica del calcolo di compenetrazione.
Fai i calcoli e fammi sapere


Ciao :)

Mandibola
29-11-2010, 09:34
non riesco a trovare l'errore, ho provato in mille modi, ma se metto i dati manualmente è corretto, mentre il processore mi da sempre lo stesso problema

Andrea Simonassi
29-11-2010, 09:55
Posso garantirti che non è il computer o il compilatore a sbagliare, verifica gli algoritmi, metti un po di ordine nel codice, rendi le funzioni rientranti.

Ti faccio anche notare che la funzione seguente è sbagliata, prendi come paramtro due cordinate che non utilizzi mai e lavori invece su variabili globali confrontando sempre e soltanto l'elemento in posizione 0 con l'elemento in posizione 1.

Verifica quello che hai scritto. ciao.




int Compenetrazione (struct coordinate posizione, struct coordinate dimensioni)
{
int i = 0,j = 1;


if ((pacchi[j].posizione.x < (pacchi[i].posizione.x + pacchi[i].dimensioni.x)) && (pacchi[j].posizione.y < (pacchi[i].posizione.y + pacchi[i].dimensioni.y)))
{
return 1;
}

if ((pacchi[j].posizione.x < (pacchi[i].posizione.x + pacchi[i].dimensioni.x)) && (pacchi[j].posizione.z < (pacchi[i].posizione.z + pacchi[i].dimensioni.z)))
{
return 1;
}

if ((pacchi[j].posizione.z < (pacchi[i].posizione.z + pacchi[i].dimensioni.z)) && (pacchi[j].posizione.y < (pacchi[i].posizione.y + pacchi[i].dimensioni.y)))
{
return 1;
}
return 0;
}



Ciao

Mandibola
29-11-2010, 10:04
Ciao,
intanto grazie.
Mi sembra che l'errore sia nella funzione compenetrazione;
non capisco, cosa intendi con "rendi le funzioni rientranti"?
Le funzioni wrong position e stabilità a livello di algoritmo mi sembrano corrette;
ti chiedo: come faccio a passare le struct alle funzioni in modo corretto, in maniera tale che vengano confontate a due a due?

Loading