Pagina 1 di 3 1 2 3 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 24
  1. #1

    [C] funzioni di controllo spaziale

    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:
    codice:
    #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;
    }
    ]

  2. #2
    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

  3. #3
    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.

  4. #4
    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
    codice:
    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
    codice:
    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
    codice:
    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

  5. #5
    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

  6. #6
    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

  7. #7
    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

  8. #8
    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

  9. #9
    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.


    codice:
    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

  10. #10
    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?

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.