Programacion: Interpolacion de una matriz

[masteries]

Saludos,

Necesito implementar en lenguage C la interpolación de una matriz de 16x16 valores y convertirla en una de 256x256 valores.
Estoy utilizando la librería SDL, pero el método de interpolación que me he sacado de la manga es "malo" con ganas o estoy haciendo algo mal.
Porque lo raro es que algunas de las líneas verticales salen perfectas, pero otras son un desastre. Si eso pongo una imagen dentro de un rato.

El resultado final debe ser un "heatmap" con unos 16 o 32 tonos de color.

Adjunto el cutre-código:

void draw_heatmap()
{
    // Vamos a dibujar píxeles en pantalla
    SDL_Surface *pantalla, *recuadro;

    // Variables auxiliares

    SDL_Rect destino;
    Uint32 color[18];
    SDL_Event evento;
    unsigned int i;
    unsigned int j;
    unsigned int cx;
    unsigned int cy;
    unsigned int aux_color;
    unsigned char xi,yi,xo,yo,x_count,y_count,count,change;
    signed char sentido,distance;

    //Paleta de color, 16 colores desde el azul al rojo

    color[1] = SDL_MapRGB(screen->format, 0, 0, 255);
    color[2] = SDL_MapRGB(screen->format, 0, 67, 255);
    color[3] = SDL_MapRGB(screen->format, 0, 131, 255);
    color[4] = SDL_MapRGB(screen->format, 0, 195, 255);
    color[5] = SDL_MapRGB(screen->format, 0, 255, 249);
    color[6] = SDL_MapRGB(screen->format, 0, 255, 181);
    color[7] = SDL_MapRGB(screen->format, 0, 255, 118);
    color[8] = SDL_MapRGB(screen->format, 0, 255, 53);
    color[9] = SDL_MapRGB(screen->format, 10, 255, 0);
    color[10] = SDL_MapRGB(screen->format, 74, 255, 0);
    color[11] = SDL_MapRGB(screen->format, 138, 255, 0);
    color[12] = SDL_MapRGB(screen->format, 202, 255, 0);
    color[13] = SDL_MapRGB(screen->format, 255, 242, 0);
    color[14] = SDL_MapRGB(screen->format, 255, 175, 0);
    color[15] = SDL_MapRGB(screen->format, 255, 112, 0);
    color[16] = SDL_MapRGB(screen->format, 255, 47, 0);

    // Obtenemos el color blanco

    color[0] = SDL_MapRGB(screen->format, 0, 0, 0);//Negro
    SDL_FillRect(screen, NULL, color[0]);
    SDL_Flip(screen);
    color[17] = SDL_MapRGB(screen->format, 255, 255, 255);//Blanco

    //Datos originales, [x][y]
    orig_data[0][0] = 1;
    orig_data[1][0] = 1;
    orig_data[2][0] = 1;
    orig_data[0][1] = 1;
    orig_data[1][1] = 16;
    orig_data[2][1] = 1;
    orig_data[0][2] = 1;
    orig_data[1][2] = 1;
    orig_data[2][2] = 1;

    //Interpolar datos

//Eje X
for(yo=0;yo<3;yo++)
{
for(xo=0;xo<2;xo++)
{
 interp_data[xi][yi] = orig_data[xo][yo];
 distance = orig_data[xo][yo] - orig_data[xo+1][yo];
 if(distance<0)
 {
     sentido = 1;//ASCENDENTE
 }
 else
 {
     sentido = -1;//DESCENDENTE
 }
 distance = abs(distance);
 distance += 1;
 change = 16/distance;
 aux_color = interp_data[xi][yi];

 count = 0;
 for(x_count=0;x_count<15;x_count++)
 {
  if(count==change)
  {
   count=0;
   aux_color = aux_color + sentido;
    if(aux_color<1)
    {
     aux_color = 1;
    }
    if(aux_color>16)
    {
     aux_color = 16;
    }
  }
  interp_data[xi+x_count][yi] = aux_color;
  count++;
  }//fin for x_count
  xi += 15;
 }//Fin for xo
interp_data[xi][yi] = orig_data[2][yo];
yi += 15;
xi = 0;
}//Fin for yo



for(xi=0;xi<31;xi++)
{
 for(yi=0;yi<30;yi+=15)
  {
  aux_color = interp_data[xi][yi];
  distance = interp_data[xi][yi] - interp_data[xi][yi+15];
    if(distance<0)
       {
        sentido = 1;
       }
     else
       {
        sentido = -1;
       }
     distance = abs(distance);
     distance += 1;
     change = 16/distance;
     count=0;
  for(y_count=0;y_count<15;y_count++)
  {
   if(count==change)
   {
    count=0;
    aux_color = aux_color + sentido;
    if(aux_color<1)
    {
     aux_color = 1;
    }
    if(aux_color>16)
    {
     aux_color = 16;
    }
   }
 interp_data[xi][yi+y_count] = aux_color;
 count++;
  }

  }//Fin de for yi
}//Fin de for xi

    //Dibujar datos originales

    destino.w = 16;
    destino.h = 16;
    cx = 0;
    cy = 0;
    i = 0;//x
    j = 0;//y

 while(cy<48)
   {
    while(cx<48)
      {
       destino.x = cx;
       destino.y = cy;
       aux_color = orig_data[i][j];
       SDL_FillRect(screen, &destino, color[aux_color]);
       cx += 16;
       i += 1;
      }
      cy += 16;
      cx = 0;
      i = 0;
      j += 1;
   }

    //Dibujar datos interpolados

    destino.w = 5;
    destino.h = 5;
    cx = 56;
    cy = 56;
    i = 0;//x
    j = 0;//y

 while(cy<211)
   {
    while(cx<211)
      {
       destino.x = cx;
       destino.y = cy;
       aux_color = interp_data[i][j];
       SDL_FillRect(screen, &destino, color[aux_color]);
       cx += 5;
       i += 1;
      }
      cy += 5;
      cx = 56;
      i = 0;
      j += 1;
   }

  SDL_Flip(screen);
  WaitForKey();

}

Gracias anticipadas, por las futuras respuestas.

[Jurk]

Saludos,

Necesito implementar en lenguage C la interpolación de una matriz de 16x16 valores y convertirla en una de 256x256 valores.
Estoy utilizando la librería SDL, pero el método de interpolación que me he sacado de la manga es "malo" con ganas o estoy haciendo algo mal.
Porque lo raro es que algunas de las líneas verticales salen perfectas, pero otras son un desastre. Si eso pongo una imagen dentro de un rato.

El resultado final debe ser un "heatmap" con unos 16 o 32 tonos de color.

Adjunto el cutre-código:

void draw_heatmap()
{
    // Vamos a dibujar píxeles en pantalla
    SDL_Surface *pantalla, *recuadro;

    // Variables auxiliares

    SDL_Rect destino;
    Uint32 color[18];
    SDL_Event evento;
    unsigned int i;
    unsigned int j;
    unsigned int cx;
    unsigned int cy;
    unsigned int aux_color;
    unsigned char xi,yi,xo,yo,x_count,y_count,count,change;
    signed char sentido,distance;

    //Paleta de color, 16 colores desde el azul al rojo

    color[1] = SDL_MapRGB(screen->format, 0, 0, 255);
    color[2] = SDL_MapRGB(screen->format, 0, 67, 255);
    color[3] = SDL_MapRGB(screen->format, 0, 131, 255);
    color[4] = SDL_MapRGB(screen->format, 0, 195, 255);
    color[5] = SDL_MapRGB(screen->format, 0, 255, 249);
    color[6] = SDL_MapRGB(screen->format, 0, 255, 181);
    color[7] = SDL_MapRGB(screen->format, 0, 255, 118);
    color[8] = SDL_MapRGB(screen->format, 0, 255, 53);
    color[9] = SDL_MapRGB(screen->format, 10, 255, 0);
    color[10] = SDL_MapRGB(screen->format, 74, 255, 0);
    color[11] = SDL_MapRGB(screen->format, 138, 255, 0);
    color[12] = SDL_MapRGB(screen->format, 202, 255, 0);
    color[13] = SDL_MapRGB(screen->format, 255, 242, 0);
    color[14] = SDL_MapRGB(screen->format, 255, 175, 0);
    color[15] = SDL_MapRGB(screen->format, 255, 112, 0);
    color[16] = SDL_MapRGB(screen->format, 255, 47, 0);

    // Obtenemos el color blanco

    color[0] = SDL_MapRGB(screen->format, 0, 0, 0);//Negro
    SDL_FillRect(screen, NULL, color[0]);
    SDL_Flip(screen);
    color[17] = SDL_MapRGB(screen->format, 255, 255, 255);//Blanco

    //Datos originales, [x][y]
    orig_data[0][0] = 1;
    orig_data[1][0] = 1;
    orig_data[2][0] = 1;
    orig_data[0][1] = 1;
    orig_data[1][1] = 16;
    orig_data[2][1] = 1;
    orig_data[0][2] = 1;
    orig_data[1][2] = 1;
    orig_data[2][2] = 1;

    //Interpolar datos

//Eje X
for(yo=0;yo<3;yo++)
{
for(xo=0;xo<2;xo++)
{
 interp_data[xi][yi] = orig_data[xo][yo];
 distance = orig_data[xo][yo] - orig_data[xo+1][yo];
 if(distance<0)
 {
     sentido = 1;//ASCENDENTE
 }
 else
 {
     sentido = -1;//DESCENDENTE
 }
 distance = abs(distance);
 distance += 1;
 change = 16/distance;
 aux_color = interp_data[xi][yi];

 count = 0;
 for(x_count=0;x_count<15;x_count++)
 {
  if(count==change)
  {
   count=0;
   aux_color = aux_color + sentido;
    if(aux_color<1)
    {
     aux_color = 1;
    }
    if(aux_color>16)
    {
     aux_color = 16;
    }
  }
  interp_data[xi+x_count][yi] = aux_color;
  count++;
  }//fin for x_count
  xi += 15;
 }//Fin for xo
interp_data[xi][yi] = orig_data[2][yo];
yi += 15;
xi = 0;
}//Fin for yo



for(xi=0;xi<31;xi++)
{
 for(yi=0;yi<30;yi+=15)
  {
  aux_color = interp_data[xi][yi];
  distance = interp_data[xi][yi] - interp_data[xi][yi+15];
    if(distance<0)
       {
        sentido = 1;
       }
     else
       {
        sentido = -1;
       }
     distance = abs(distance);
     distance += 1;
     change = 16/distance;
     count=0;
  for(y_count=0;y_count<15;y_count++)
  {
   if(count==change)
   {
    count=0;
    aux_color = aux_color + sentido;
    if(aux_color<1)
    {
     aux_color = 1;
    }
    if(aux_color>16)
    {
     aux_color = 16;
    }
   }
 interp_data[xi][yi+y_count] = aux_color;
 count++;
  }

  }//Fin de for yi
}//Fin de for xi

    //Dibujar datos originales

    destino.w = 16;
    destino.h = 16;
    cx = 0;
    cy = 0;
    i = 0;//x
    j = 0;//y

 while(cy<48)
   {
    while(cx<48)
      {
       destino.x = cx;
       destino.y = cy;
       aux_color = orig_data[i][j];
       SDL_FillRect(screen, &destino, color[aux_color]);
       cx += 16;
       i += 1;
      }
      cy += 16;
      cx = 0;
      i = 0;
      j += 1;
   }

    //Dibujar datos interpolados

    destino.w = 5;
    destino.h = 5;
    cx = 56;
    cy = 56;
    i = 0;//x
    j = 0;//y

 while(cy<211)
   {
    while(cx<211)
      {
       destino.x = cx;
       destino.y = cy;
       aux_color = interp_data[i][j];
       SDL_FillRect(screen, &destino, color[aux_color]);
       cx += 5;
       i += 1;
      }
      cy += 5;
      cx = 56;
      i = 0;
      j += 1;
   }

  SDL_Flip(screen);
  WaitForKey();

}

Gracias anticipadas, por las futuras respuestas.

Puesto en negrita: el for solo llega hasta el dos?
No me hagas mucho caso pero no tienes en cuenta la ultima columna, y claro, para mi que por eso no va bien...
Ademas, este metodo para 3x3 o asi esta bien pero, porque te complicas tanto? Utiliza funciones alma candida!

Mira, me he picado, ahora me bajo el dev-cpp y te hago algo del estilo pero solo con numeros

[masteries]

Gracias Jurk.

El for llega hasta el 2 porque la tercera columna no genera interpolaciones con una cuarta columna, pues esta no existe.

De todas formas he logrado sacar algo aceptable, lo suyo sería haber aplicado el formulote de la interpolación bilineal, pero vamos que es algo sólo necesario para salir del paso, y de las contadas cosas que he programado para PC.

Ahora sólo me queda dibujar el centro de gravedad de la matriz a la derecha y recibir una matriz de 16x16 por USB. Pero eso ya otro día.

[Jurk]

Es un poco chapucero pero funciona, estoy oxidado!

MIRATE LA FUNCION CUENTAALREDEDOR, es lo que buscas! Eso si, deberia de ser modificado para que no interpole solo en 3 casillas, y que la interpolacion este mas o menos centrada...

#include <iostream>
using namespace std;


const int MAXFIL = 3;
const int MAXCOL = 3;
const int ESCALA = 4;




void verArray (unsigned int * arr, int mFil, int mCol)
{
     for (int y =0; y<mFil; y++)
     {
         
         for (int x=0; x<mCol; x++) 
         {
             printf ("%4d",arr [y*mCol + x]); //utilizo un puntero, pero lo uso como array
                                                              //trampeandolo
                                                               
         }
         cout << endl;
     }
}


int cuentaAlrededor (unsigned int * arr, int posY, int posX, int mFil, int mCol, int &cant)
{
    cant =0;
    int valor =0;
    for (int y=posY-1; y<=posY+1;y++)
    {
        for (int x=posX-1; x<=posX+1; x++)
        {
            if ( !(x<0)&& !(x>=mCol) && !(y<0) && !(y>=mFil))
            {
                 cant++;
                 valor += arr[y*mFil + x];
            }
        }
    }
    return valor;
    
    
}


void interpolar (unsigned int * arrEsc, unsigned int * arrN, int mFil, int mCol)
{
     int cantidad;
     int valor;
     float num,den,res;
     
     
     for (int y =0; y<mFil; y++)
     {
         for (int x=0; x<mCol; x++) 
         {
             valor =  cuentaAlrededor (arrEsc,y,x,mFil,mCol,cantidad);
             num =valor;
             den = cantidad;
             res = num /den;
             
             arrN[y*mFil+x]= 0.5 + res;
         }
     }
     
     
}












int main()
{
    unsigned int imgOrig[MAXFIL][MAXCOL]= {1,1,1,1,16,1,1,1,1};
    unsigned int imgEscala[MAXFIL*ESCALA] [MAXCOL*ESCALA]={0};
    unsigned int imgNuevo[MAXFIL*ESCALA] [MAXCOL*ESCALA]={0};
    //vemos array original
    verArray (&imgOrig[0][0],MAXFIL,MAXCOL);
    cout <<endl<<endl;
    
    //ampliamos
    for (int y=0; y<MAXFIL;y++)
    {
        for (int x=0; x<MAXCOL; x++)
        {
            for (int yy=0; yy<ESCALA; yy++) for (int xx=0; xx<ESCALA;xx++)  imgEscala[y*ESCALA+yy][x*ESCALA+xx]= imgOrig[y][x];
        }
    }      
  
    //vemos el nuevo array sin interpolar
    verArray (&imgEscala[0][0],MAXFIL*ESCALA,MAXCOL*ESCALA);
    cout <<endl<<endl;
    
    //vemos el nuevo array  interpolado
    interpolar (&imgEscala[0][0], &imgNuevo[0][0],MAXFIL*ESCALA,MAXCOL*ESCALA);
    verArray (&imgNuevo[0][0],MAXFIL*ESCALA,MAXCOL*ESCALA);
    cout <<endl<<endl;
    
    
    system ("pause");
    return 0;
}

[pakoito]

jajajajajajajjajajajajajajajajajajajajaja no quiero ni acordarme, esto de las matrices es como volver a ver escenas de la guerra xD

Haceros con unos scripts de autoformat por favor, mis pobres ogos

[Jurk]

jajajajajajajjajajajajajajajajajajajajaja no, esto es como volver a ver escenas de la guerra xD

Haceros con unos scripts de autoformat por favor, mis pobres ogos

buenopues...

pasamelo por un autoformat de los tuyos para ver como deberia quedar... que la verdad es que a mi nadie me ha enseñado las reglas de como poner formato en el codigo, y para mi sto es lo mas claro....
@masteries
MEJORADO PARA INTERPOLAR 3x3, 4x4,5x5 o lo que sea

int cuentaAlrededor (unsigned int * arr, int posY, int posX, int mFil, int mCol, int esc, int &cant)
{
    cant =0;
    int valor =0;
    int min,max;
    max = esc/2;
    min = esc%2 + esc/2 -1;
    for (int y=posY-min; y<=posY+max;y++)
    {
        
        for (int x=posX-min; x<=posX+max; x++)
        {
            if ( !(x<0)&& !(x>=mCol) && !(y<0) && !(y>=mFil))
            {
                 cant++;
                 valor += arr[y*mFil + x];
            }
        }
    }
    return valor;
    
    
}


void interpolar (unsigned int * arrEsc, unsigned int * arrN, int mFil, int mCol, int esc)
{
     int cantidad;
     int valor;
     float num,den,res;
     
     
     for (int y =0; y<mFil; y++)
     {
         for (int x=0; x<mCol; x++) 
         {
             valor =  cuentaAlrededor (arrEsc,y,x,mFil,mCol,esc,cantidad);
             num =valor;
             den = cantidad;
             res = num /den;
             
             arrN[y*mFil+x]= 0.5 + res;
         }
     }
     
     
}

[pakoito]

Como soy un degenerado yo uso Eclipse para programar incluso C++, y vienen de serie unos autoformat decentes ya que puedes modificar a mano. El de mi exjefe era un poco raro asi que no te lo recomiendo, pero los que vienen de serie es dar a la hotkey (Control+shift+F creo recordar) and pluf! todo formateado. Creo que los hay similares para Sublime y Notepad++. Y siempre puedes adaptarlos a tu gusto, pero al menos son consistentes.

El mayor fallo que te he visto han sido dos for en una misma línea, un for sin corchetes y no abusar de paréntesis en un condicional, lo que le quita legibilidad. Pero luego tienes inconsistencias en el espaciado esparcidas por todo el código.

Pero bueno, luego ya lo obsesivo-compulsivo que seas con tu código, mi primer jefe me hizo casi paranoico -.-

Evita también abusar de negativos, cambia los statement negativos para que sea positivos en la medida de lo posible, el '!' quita mucha legibilidad y sólo debería usarse en '!='. Además creo es más pesado para el procesador por tener que hacer una instrucción más.

if ( !(x<0)&& !(x>=mCol) && !(y<0) && !(y>=mFil))

if (((x > 0) && (x < mCol)) && ((y > 0) && (y < mFil)))

// Mira si x e y están DENTRO de los límites, en vez de mirar si están FUERA de ellos. Más fácil de leer y de entender para el que venga detrás.
// En este caso no, pero en otros similares si abusas de paréntesis puedes conseguir una puntita en rendimiento porque escapará antes del condicional.

[Jurk]

lo de los dos for no lo suelo hacer, auque lo he visto a profesores de la uni... yo esta vez no se ni por que lo he hecho.
lo del for sin corchetes, mas de lo mismo

Y lo de las negaciones... tiendo a no usarlos, auque tambien tiendo a poner condiciones segun las digo en voz alta, y claro, tiendo a escribirlos tal cual. Y me gustan mas los AND que los OR

-----Actualizado-----

Como soy un degenerado yo uso Eclipse para programar incluso C++, y vienen de serie unos autoformat decentes ya que puedes modificar a mano. El de mi exjefe era un poco raro asi que no te lo recomiendo, pero los que vienen de serie es dar a la hotkey (Control+shift+F creo recordar) and pluf! todo formateado. Creo que los hay similares para Sublime y Notepad++.

El mayor fallo que te he visto han sido dos for en una misma línea, un for sin corchetes y no abusar de paréntesis en un condicional, lo que le quita legibilidad. Pero luego tienes inconsistencias en el espaciado esparcidas por todo el código.

Pero bueno, luego ya lo obsesivo-compulsivo que seas con tu código, mi primer jefe me hizo casi paranoico -.-

Evita también abusar de negativos, cambia el statement negativos para que sea positivos en la medida de lo posible, el ! quita mucha legibilidad y sólo debería usarse en !=



if ((x > 0) || (x <= mCol) || (y > 0) || (y <= mFil))

explicame mejor lo de las inconsistencias

[pakoito]

Te he arreglado lo de las negaciones y explicado por qué evitarlas, mira el edit.

Respecto a los espacios:

cant =0; // asignación sin espacio después del igual
int valor =0;
max = esc/2; // asignación con espacio después del igual

int cuentaAlrededor (unsigned int * arr, int posY, int posX, int mFil, int mCol, int esc, int &cant) // lista de elementos con espacios
int min,max; // lista de elementos sin espacios
valor = cuentaAlrededor (arrEsc,y,x,mFil,mCol,esc,cantidad); // lista de elementos sin espacios

for (int y =0; y<mFil; y++) // asignación sin espacio
{
for (int x=0; x<mCol; x++) // asignación sin menos espacio
{

Y ésto ya es obsesivo-compulsivo:

for (int y=posY-1; y<=posY+1;y++) // burruño a, sin espacio antes de y++
{

for (int x=posX-min; x<=posX+max; x++) // burruño b, con espacio antes de x++
{

// lo normal es meter espacios entre operadores, y paréntesis en checkeos y asignaciones

for (int x = (posX-min); x <= (posX + max); x++) {...}

// y nadie te echaría en cara si crearas dos variables previas antes inicio y fin, o suelo y techo, que almacenaran los valores ya que posx ni min ni max cambian a lo largo de la ejecución, y en multihilo te podrías hasta evitar lios si te modificaran las variables al vuelo desde otro lado

int floor = posX - min;
int ceiling = posX + max;
for (floor; floor <= ceiling; floor++) {...}

// es más

int distance = max + min + (esc % 2);
while (distance >= 0) { ...; distance--; }

// aunque creo que -- es más pesado que ++, pero te quedas con el mismo número de elementos que creaste originalmente.
// EDIT: for está optimizado por algunos compiladores, asi que aquí me he flipado un poco tal vez.

[Jurk]

joe con el tio Paco, pensando en rendimiento y tal!!! Como se nota que te ha fichao una Major el London...

La verdad es que el codigo me ha quedado bastatnte guarrete, por la rapidez, pero nada demasiado grave... con las jajas que te has echado pensaba que ya estaba haciendo unas MEGA-CAGADAS que no conocia. Y gracias por los comments, los tendre en cuenta

[pakoito]

No, las jajajajaj era porque solo pensar en interpolación de matrices ya me daban escalofríos de los malos recuerdos de mates xD

joe con el tio Paco, pensando en rendimiento y tal!!! Como se nota que te ha fichao una Major el London...

Como dije ya en otros sitios la he cagado cienmil veces en cosas de éstas, asi que voy aprendiendo poco a poco. Acho, lo que he hecho en entrevistas no entra en un libro jajaja

[Jurk]

// es más

int distance = max + min;
while (distance >= 0) { ...; distance--; }

// aunque creo que -- es más pesado que ++, pero te quedas con el mismo número de elementos que creaste originalmente

No contabas con mi astucia!!

max = esc/2;
    min = esc%2 + esc/2 -1;


Si la interpolacion fuese de 4 elementos (par), max valdria 2 y min 1, y por lo tanto el for haria -1, 0, 1, 2 -> 4 elementos
Si fuese de cinco (impar) max valdria 2 y min 2, y el for iria -2, -1, 0, 1, 2 -> 5 elementos

[pakoito]

Uuuh, ahí me has pillado

EDIT: Voy a leerme el enunciado, pero distancia no es igual a esc?

[Jurk]

es que el resto es el resto! Que primero lo pruebo varias veces en el papel para saber ya directamente que programar!

BORRADO...

Si, distancia (tu variable) deberia tener el mismo valor que la variable escala
mmm... no lo se, lo unico que he hecho ha sido ampliar un cuadrado de 3x3 en uno de 9x9, o 12x12, o 15x15, segun la escala, y luego, interpolar el valor de grupos de 3x3, o 4x4, o 5x5 de esa misma matriz ampliada. Para hacerlo facil el grupo de interpolacion tiene el mismo alto y ancho que la escala a la que amplio la matriz.

ampliacion de 3 y grupo de interpolacion de 3x3

   1   1   1
   1  16   1
   1   1   1




   1   1   1   1   1   1   1   1   1
   1   1   1   1   1   1   1   1   1
   1   1   1   1   1   1   1   1   1
   1   1   1  16  16  16   1   1   1
   1   1   1  16  16  16   1   1   1
   1   1   1  16  16  16   1   1   1
   1   1   1   1   1   1   1   1   1
   1   1   1   1   1   1   1   1   1
   1   1   1   1   1   1   1   1   1




   1   1   1   1   1   1   1   1   1
   1   1   1   1   1   1   1   1   1
   1   1   3   4   6   4   3   1   1
   1   1   4   8  11   8   4   1   1
   1   1   6  11  16  11   6   1   1
   1   1   4   8  11   8   4   1   1
   1   1   3   4   6   4   3   1   1
   1   1   1   1   1   1   1   1   1
   1   1   1   1   1   1   1   1   1




Press any key to continue . . .

[pakoito]

Asi que básicamente tienes un for de 3 y otro de escala, sin usar cálculos raros. Burruños a y b resueltos xD

-----Actualizado-----

Pair programming success!