Programma GestioneImmagini con matrice di booleani

[m3phisto]

Ciao ragazzi, è la prima volta che scrivo qui sul forum, ed ho bisogno del vostro aiuto.
Allora ho da risolvere un problema d'esame, del quale sono riuscito a risolverne una parte, ma ora ho un altro problema.

La traccia è questa:


Questo è il codice svolto fino ad ora:

public class GestioneImmagini {

    public static int[] comprimiMatrice(boolean[][]M){
        int[] v= new int[2];
        int[] v2=new int[M.length*M[0].length];
        v[0]=M.length;
        v[1]=M[0].length;
        int bianchi=0;
        int neri=0;
        int i=0;
        
        int l=0;
        boolean cambiato=false;

        while(i < M.length){
            if(i > 0 && M[i] != M[i-1]){
                System.out.println("i= "+ i + "rilevato cambiamento");
                if(M[i] == true){    //neri
                System.out.println("Gli ultimi elementi erano neri");
                v2[l++]=neri;
                neri=0;
                }
                else //bianchi
                {
                    System.out.println("Gli ultimi elementi erano bianchi");
                    v2[l++]=bianchi*-1;
                    bianchi=0;
                }
        }
            if(M[i] == false){
                System.out.println("L'elemento corrente è un bianco (i= "+i+")");
                        bianchi++;
            }
            else{
                System.out.println("L'elemento corrente è un nero (i= "+i+")");
                neri++;
            }
        
        j++;
        
        

        if(i >= M[0].length) //elemento cambiato rispetto al precedente
        {
            System.out.println("i = "+ i +" rilevato cambiamento");
            if(M[i-1] == true) //neri
            {
                System.out.println("Gli ultimi elementi erano neri");
                    v2[l++]=neri;
            }
            else
            {
                System.out.println("Gli ultimi elementi erano bianchi");
                v2[l++]=bianchi*-1;
            }
            
        }
       

    }
        
        
        return v2;
    }



    public static int[] comprimiArray(boolean[] B1){
        int[] V1=new int[B1.length];
        int bianchi=0;
        int neri=0;
        int i = 0;
        int l = 0;
        boolean cambiato = false;
        
        while(i < B1.length)
        {
            if(i > 0 && B1[i] != B1[i-1]) // se l'elemento è cambiato rispetto al precedente
            {
                System.out.println("i = " + i + " rilevato cambiamento");
                if(B1[i-1] == true) //neri
                {
                    System.out.println("Gli ultimi elementi erano neri");
                    V1[l++] = neri;
                    neri=0;
                }
                else //bianchi
                {
                    System.out.println("Gli ultimi elementi erano bianchi");
                    V1[l++] = bianchi * -1;
                    bianchi=0;
                }
            }
            if(B1[i] == false)
            {
                System.out.println("L'elemento corrente e' un bianco (i = " + i + ")");
                bianchi++;
            }
            else
            {
                 System.out.println("L'elemento corrente e' un nero (i = " + i + ")");
                neri++;
            }

            i++;

            if(i == B1.length) // se l'elemento è cambiato rispetto al precedente
            {
                    System.out.println("i = " + i + " rilevato cambiamento");
                    if(B1[i-1] == true) //neri
                {
                    System.out.println("Gli ultimi elementi erano neri");
                    V1[l++] = neri;
                }
                else //bianchi
                {
               System.out.println("Gli ultimi elementi erano bianchi");
                    V1[l++] = bianchi * -1;
                }
            }

            
        }
        
        return V1;

    }
    public static void main (String[] args){
        int[] V1;
        int[] v2;
        boolean[][] M={{false,false,true,false,false},
                       {false,true,true,true,false},
                       {true,true,true,true,true},
                       {false,true,true,true,false},
                       {false,false,true,false,false}};

       boolean[] B1={false,false,true,false,false};
        V1=comprimiArray(B1);
        for(int i=0;i<V1.length;i++)
        System.out.println(V1[i]);
        
        v2=comprimiMatrice(M);
        for(int i=0;i<v2.length;i++)
            System.out.println(v2[i]);
        

    }
 }

Ho svolto il metodo del comprimiArray, ma ora non riesco a risolvere il metodo del comprimiMatrice, in quanto mi legge solo la prima riga e si ferma, tra l'altro mi dà anche qualche eccezione.
Mi potreste aiutare a capire come fare? Vi ringrazio

[andbin]

Originariamente inviato da m3phisto
Ho svolto il metodo del comprimiArray, ma ora non riesco a risolvere il metodo del comprimiMatrice

Premetto subito che quanto hai scritto non è il massimo, non è fatto nel modo più logico e oltretutto non rispetta alcuni punti della traccia.

Partiamo da una questione fondamentale, che sicuramente hai già colto: la dimensione dell'array in output dipende non soltanto dalla dimensione della matrice di input ma ... anche dal suo contenuto!!
Questa è una classica situazione in cui non si sa a priori la quantità di dati da generare in output. La traccia lo fa ben notare suggerendo il seguente approccio: istanziare un array sovradimensionato per il caso "peggiore" e poi alla fine istanziare un altro array della giusta dimensione ricopiando solo i dati utilizzati.
Già questo non l'hai fatto .....

Poi la traccia suggerisce che per realizzare la compressione in comprimiMatrice() si dovrebbero realizzare 2 metodi ausiliari comprimiArray() e accodaArray(). Chiaramente dovranno essere entrambi invocati da comprimiMatrice() in modo molto semplice: comprimiArray() comprime una riga della matrice, il risultato è poi accodato nell'array sovradimensionato grazie ad accodaArray(). E anche questo non l'hai fatto ....

[m3phisto]

come faccio ad invocare il metodo comprimiArray, per ogni riga della matrice?

[andbin]

Originariamente inviato da m3phisto
come faccio ad invocare il metodo comprimiArray, per ogni riga della matrice?

Gli passi M[riga]. Fai un ciclo sulle righe della matrice, ovviamente.

[LeleFT]

Regolamento, punto 6:

Formattazione del codice sorgente.
Quando incollate una porzione di codice all'interno di un messaggio, utilizzate l'apposito tag
[CODE]
codice
[/CODE]
che può essere inserito automaticamente premendo il pulsante CODE: questo renderà il codice leggibile e facilmente comprensibile a tutti, agevolando gli utenti che desiderano aiutarvi.

Ciao.

[m3phisto]

Originariamente inviato da andbin
Gli passi M[riga]. Fai un ciclo sulle righe della matrice, ovviamente.

ho modificato il codice,le correzioni che mi hai segnalato, sono giustissime ed infatti le farò non appena avrò completato i metodi.
Ho modificato il codice, passando al metodo comprimiArray le M[riga]; la scansione viene eseguita ma in output ricevo solo il vettore di interi della prima riga:

public class GestioneImmagini {

    public static int[] comprimiMatrice(boolean[][]M){
        int[] v= new int[2];
        int[] v2=new int[M.length*M[0].length];
        v[0]=M.length;
        v[1]=M[0].length;

        for(int i=0;i<M.length;i++)
            v2=comprimiArray(M[i]);
        
        return v2;
    }



    public static int[] comprimiArray(boolean[] B1){
        int[] V1=new int[B1.length];
        int bianchi=0;
        int neri=0;
        int i = 0;
        int l = 0;
        boolean cambiato = false;
        
        while(i < B1.length)
        {
            if(i > 0 && B1[i] != B1[i-1]) // se l'elemento è cambiato rispetto al precedente
            {
                System.out.println("i = " + i + " rilevato cambiamento");
                if(B1[i-1] == true) //neri
                {
                    System.out.println("Gli ultimi elementi erano neri");
                    V1[l++] = neri;
                    neri=0;
                }
                else //bianchi
                {
                    System.out.println("Gli ultimi elementi erano bianchi");
                    V1[l++] = bianchi * -1;
                    bianchi=0;
                }
            }
            if(B1[i] == false)
            {
                System.out.println("L'elemento corrente e' un bianco (i = " + i + ")");
                bianchi++;
            }
            else
            {
                 System.out.println("L'elemento corrente e' un nero (i = " + i + ")");
                neri++;
            }

            i++;

            if(i == B1.length) // se l'elemento è cambiato rispetto al precedente
            {
                    System.out.println("i = " + i + " rilevato cambiamento");
                    if(B1[i-1] == true) //neri
                {
                    System.out.println("Gli ultimi elementi erano neri");
                    V1[l++] = neri;
                }
                else //bianchi
                {
               System.out.println("Gli ultimi elementi erano bianchi");
                    V1[l++] = bianchi * -1;
                }
            }

            
        }
        
        return V1;

    }
    public static void main (String[] args){
        int[] V1;
        int[] v2;
        boolean[][] M={{false,false,true,false,false},
                       {false,true,true,true,false},
                       {true,true,true,true,true},
                       {false,true,true,true,false},
                       {false,false,true,false,false}};

       boolean[] B1={false,false,true,false,false};
        /*V1=comprimiArray(B1);
        for(int i=0;i<V1.length;i++)
        System.out.println(V1[i]);  
        */
        v2=comprimiMatrice(M);
        for(int i=0;i<v2.length;i++)
            System.out.println(v2[i]);
        

    }
 }

Questo è l'output

L'elemento corrente e' un bianco (i = 0)
L'elemento corrente e' un bianco (i = 1)
i = 2 rilevato cambiamento
Gli ultimi elementi erano bianchi
L'elemento corrente e' un nero (i = 2)
i = 3 rilevato cambiamento
Gli ultimi elementi erano neri
L'elemento corrente e' un bianco (i = 3)
L'elemento corrente e' un bianco (i = 4)
i = 5 rilevato cambiamento
Gli ultimi elementi erano bianchi
L'elemento corrente e' un bianco (i = 0)
i = 1 rilevato cambiamento
Gli ultimi elementi erano bianchi
L'elemento corrente e' un nero (i = 1)
L'elemento corrente e' un nero (i = 2)
L'elemento corrente e' un nero (i = 3)
i = 4 rilevato cambiamento
Gli ultimi elementi erano neri
L'elemento corrente e' un bianco (i = 4)
i = 5 rilevato cambiamento
Gli ultimi elementi erano bianchi
L'elemento corrente e' un nero (i = 0)
L'elemento corrente e' un nero (i = 1)
L'elemento corrente e' un nero (i = 2)
L'elemento corrente e' un nero (i = 3)
L'elemento corrente e' un nero (i = 4)
i = 5 rilevato cambiamento
Gli ultimi elementi erano neri
L'elemento corrente e' un bianco (i = 0)
i = 1 rilevato cambiamento
Gli ultimi elementi erano bianchi
L'elemento corrente e' un nero (i = 1)
L'elemento corrente e' un nero (i = 2)
L'elemento corrente e' un nero (i = 3)
i = 4 rilevato cambiamento
Gli ultimi elementi erano neri
L'elemento corrente e' un bianco (i = 4)
i = 5 rilevato cambiamento
Gli ultimi elementi erano bianchi
L'elemento corrente e' un bianco (i = 0)
L'elemento corrente e' un bianco (i = 1)
i = 2 rilevato cambiamento
Gli ultimi elementi erano bianchi
L'elemento corrente e' un nero (i = 2)
i = 3 rilevato cambiamento
Gli ultimi elementi erano neri
L'elemento corrente e' un bianco (i = 3)
L'elemento corrente e' un bianco (i = 4)
i = 5 rilevato cambiamento
Gli ultimi elementi erano bianchi
-2
1
-2
0
0

[andbin]

Originariamente inviato da m3phisto
la scansione viene eseguita ma in output ricevo solo il vettore di interi della prima riga:

Ovvio (tra l'altro così ottieni l'ultima riga ... che guarda caso è uguale alla prima!) ... assegni l'array ritornato da comprimiArray() direttamente alla variabile v2 ... facendo "perdere" il riferimento all'array sovradimensionato!!
La traccia è chiara .... dovresti fare l'altro metodo accodaArray() per scrivere i dati di un array X (il ritorno di comprimiArray) dentro un array Y (che sarà il tuo array sovradimensionato) ad una certa posizione pos.

E giusto per chiarire un'altra cosa: vedo che in comprimiMatrice hai usato 2 array 'v' e 'v2'. Non te ne servono due .... solo uno, che sarà dimensionato altezza*larghezza+2 e in cui i primi due elementi sono altezza/larghezza della matrice originale.
Ripeto che non ti servono due array ... solo 1. E poi con accodaArray appendi man mano i dati.

[m3phisto]

Io ho creato un array sovradimensionato v2, pensando che andasse ad inserire automaticamente in ogni posizione l incrementata i valori di interi ricavati leggendo ogni riga..Non posso farlo ugualmente così? Cioè, legge la prima riga della matrice,ed inserisce i valori di interi nel vettore, occupando 3 posizioni del vettore, poi legge la seconda riga, e riprende a scrivere sul vettore dalla posizione 4..Non so se sono stato chiaro XD

[andbin]

Originariamente inviato da m3phisto
Io ho creato un array sovradimensionato v2, pensando che andasse ad inserire automaticamente in ogni posizione l incrementata i valori di interi ricavati leggendo ogni riga..Non posso farlo ugualmente così? Cioè, legge la prima riga della matrice,ed inserisce i valori di interi nel vettore, occupando 3 posizioni del vettore, poi legge la seconda riga, e riprende a scrivere sul vettore dalla posizione 4..Non so se sono stato chiaro XD

No ... non è questione di 1 assegnamento (del reference)!!! Lo ripeto: devi usare quel accodaArray(). I singoli valori dell'array ritornato da comprimiArray() li devi assegnare uno per uno a partire da una certa posizione 'pos' del tuo array sovradimensionato.
Ed è appunto questo che dovrebbe fare accodaArray!!

E già che ci sono ti dò un altro "indizio" molto utile (spero). La logica che hai usato in comprimiArray potrà anche funzionare (non l'ho controllato per bene) ma .... è lunga, vedo che fai un sacco di cose (pure moltiplicazioni per -1!!) e usi diverse variabili. La logica che hai usato va a "contare" le sequenze di true e false e usi addirittura 2 contatori!

No ... vuoi l'indizio?? Eccolo: non ti serve "contare" le sequenze. Ti basta decrementare o incrementare di 1 il valore ad un certo indice a seconda se hai un false o true.

Immagina: false, false, true, true, false. Non sai a priori quanti valori avrai, quindi istanzi un int[] arr di 5 elementi. Usi una variabile es. 'idx' inizialmente a 0.
Il primo è false, quindi decrementi arr[idx], il secondo è pure false, quindi decrementi ancora arr[idx]. Il terzo è true, ora dovresti incrementare. Però non più all'indice 0 ma all'indice 1.

Morale della favola: ti basta decrementare o incrementare in base al false/true ... cosa che si fa con 1 riga di codice (se si usa l'operatore ternario ?) o con poche righe (con if e else).
L'unica cosa particolare è il passaggio da un indice al successivo ma per questo basta il test di "diverso" tra due boolean adiacenti che oltretutto hai già scritto.

Bello l'indizio ... no?

[m3phisto]

devo dire che è molto curiosa come cosa quindi ora basta ke faccia il metodo accodaArray (con un bell'ArrayCopy) e quindi le info, vengono accodate sempre allo stesso array esatto?