Forum libero

il compito era una merda e lo sapevi già, però ho provato a farlo "bene", anche se c'erano pochi margini. A dire il vero potevo usare una variabile in meno nello scorrere l'array, ma ho privilegiato la leggibilità.
Tutto sommato però mi sembra sempre una merda.
Tu cosa ne pensi?

Testo della traccia:
Esercizio:
State lavorando al progetto di un applicativo per la gestione di immagini e, in particolare, per la
creazione di filtri che distorcano immagini memorizzate mediante la codifica bitmap con una
profondità di colore di 16 bit.
La codifica bitmap prevede che ogni pixel venga rappresentato da un valore intero (in questo caso
da 0 a 65.535) che rappresenta la sfumatura di colore.
Vi viene richiesto di realizzare una funzione, in linguaggio C++, che realizzi il filtraggio. Tale
funzione riceve in ingresso una matrice di NxM numeri interi e crea una nuova matrice modificando
i valori secondo il seguente criterio: il valore di coordinate (i,j) viene sostituito con la media dei
valori della sottomatrice con elemento superiore sinistro di coordinate (i-2, j-2) ed elemento
inferiore destro di coordinate (i+2, j+2). Chiaramente si deve considerare solo la somma degli
elementi esistenti e quindi vanno considerati con attenzione i casi in cui i e j identifichino degli
elementi vicini al contorno della matrice.
Si realizzi anche un semplice main() per testare il corretto funzionamento della funzione prodotta.

#include <iostream>
#include <iomanip>
using namespace std;

// Dichiarazione delle costanti
const int RIG = 14; //righe matrice
const int COL = 7; //colonne matrice

int stampaMat(int mat[][COL], int rig);
int filtro(int img_in[][COL], int img_out[][COL], int rig);

int main()
{
    int image[RIG][COL]={
        {11900, 11987, 11934, 11999, 12036, 12087, 12100},
        {11992, 12003, 11953, 12015, 12098, 12107, 12110},
        {12000, 12008, 12023, 12111, 12120, 12128, 12120},
        {12066, 12025, 12099, 12145, 12135, 12099, 12099},
        {12059, 12087, 12089, 12136, 12130, 12110, 12101},
        {12050, 12100, 12098, 12150, 12155, 12123, 12097},
        {1255, 12306, 12287, 12256, 12244, 12249, 12200},
        {11900, 11987, 11934, 11999, 12036, 12087, 12100},
        {11992, 12003, 11953, 12015, 12098, 12107, 12110},
        {12000, 12008, 12023, 12111, 12120, 12128, 12120},
        {12066, 12025, 12099, 12145, 12135, 12099, 12099},
        {12059, 12087, 12089, 12136, 12130, 12110, 12101},
        {12050, 12100, 12098, 12150, 12155, 12123, 12097},
        {1255, 12306, 12287, 12256, 12244, 12249, 12200},
    };
    int img_new[RIG][COL];
    stampaMat(image,RIG);
    cout << "\n";
    filtro(image,img_new,RIG);
    stampaMat(img_new,RIG);
    cout << "\n";
    return 0;
}

int stampaMat(int mat[][COL], int rig)
{
    for(int i=0;i<rig;i++)
    {        
        for(int j=0;j<COL;j++)
            cout << setw(6) << mat[i][j];
        cout << "\n";
    }
    return 0;
}

int filtro(int img_in[][COL], int img_out[][COL], int rig)
{
    for(int i=0;i<rig;i++)
    {     
        int lim_inf_r, lim_sup_r;
        //calcolo dell'indice delle righe della sottomatrice
        if (i-2<0)               //se l'elemento è "troppo in alto" 
        {
            lim_inf_r=0;
            lim_sup_r=i+2;
        }
        else if (i+2>=rig)       //se l'elemento è "troppo in basso"
        {
            lim_sup_r=rig-1;
            lim_inf_r=i-2;
        }
        else                     //se l'elemento è al centro
        {
            lim_inf_r=i-2;
            lim_sup_r=i+2;
        }
     
        for(int j=0;j<COL;j++)
        {
            int lim_inf_c, lim_sup_c;
            long subtotale=0; //per sommare dei numeri grandi, ci vuole una variabile grande
            int n_elementi;
            
            //calcolo dell'indice delle colonne della sottomatrice
            if (j-2<0)               //elemento di estrema destra
            {
                lim_inf_c=0;
                lim_sup_c=j+2;
            }
            else if (j+2>=COL )      //elemento di estrema sinistra
            {
                lim_sup_c=COL-1;
                lim_inf_c=j-2;
            }
            else                     //elemento di estremo centro<IMG SRC="images/emo/1.gif" border="0" height="20" alt="Sorride" title="Sorride">)
            {
                lim_inf_c=j-2;
                lim_sup_c=j+2;
            }
            
            //Ora che si sono calcolati gli estremi, si calcola la media della sottomatrice
            for (int sub_r=lim_inf_r; sub_r<=lim_sup_r; sub_r++)
                for (int sub_c=lim_inf_c; sub_c<=lim_sup_c; sub_c++)
                    subtotale+=img_in[sub_r][sub_c];

            n_elementi=(lim_sup_r-lim_inf_r+1)*(lim_sup_c-lim_inf_c+1);
            img_out[i][j]=subtotale/n_elementi;
        }        
    }
    return 0;
}