Ver la versión completa : Programacion: Interpolacion de una matriz
masteries
05/09/2013, 22:58
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.
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
06/09/2013, 02:29
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.
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;
}
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 [baneo]
jajajajajajajjajajajajajajajajajajajajaja no, esto es como volver a ver escenas de la guerra xD
Haceros con unos scripts de autoformat por favor, mis pobres ogos [baneo]
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 (http://www.gp32spain.com/foros/member.php?u=28729)
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;
}
}
}
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.
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
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.
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
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
// 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
Uuuh, ahí me has pillado :D
EDIT: Voy a leerme el enunciado, pero distancia no es igual a esc?
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 . . .
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!
http://www.youtube.com/watch?v=dYBjVTMUQY0
La cosa es que centrandonos en el 16 azul obtenemos el 8 en negrita
1 1 11 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
BARRUÑO: codigo que no entiendo/sin sentido ->>>> la palabra barruño era un barruño para mi
EDIT: lo bueno es que ahora, con el min y el max, es capaz de interpolar grupos de celdas de cualquier tamaño
AMpliacion de 3x y grupo de interpolacion de 7x7
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
2 3 4 3 3 3 4 3 2
4 5 6 5 5 5 6 5 4
5 7 9 7 7 7 9 7 5
4 5 6 5 5 5 6 5 4
2 3 4 3 3 3 4 3 2
1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1
Press any key to continue . . .
Un burruño es lo que haces con los calcetines o una camisa sucia, meterlo todo junto, arrugado y a bulto donde encaje. Sea la cesta, el armario o el suelo. Luego viene tu madre y dice "hijo no me emburruñes las camisas que luego no se estiran ni planchando". Es algo demasiado apretujado y lleno de cosas, no necesariamente incomprensible.
burruño
m. vulg. gurruño.
gurruño
m. Lo que está arrugado, encogido o mal hecho:
siempre lleva los pantalones hechos un gurruño.
No era un burruño, estaba bien pensado, mira que no he usado esa tecnica ni nada, por ejemplo al programar juegos de la vida para chequear las casillas adyacentes....
No era un burruño, estaba bien pensado, mira que no he usado esa tecnica ni nada, por ejemplo al programar juegos de la vida para chequear las casillas adyacentes....
Cierto, usas posX y posY como la base, no me habia fijado que estás usando luego el valor de x e y dentro. Derp. Lo dicho, me leo las cosas a medias xD
masteries
http://en.wikipedia.org/wiki/Bilinear_interpolation
-----Actualizado-----
jo, y tenia una cagadilla en la version mejorada que ya he corregido
Nathrezim
06/09/2013, 10:46
// 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.
¿No es al revés? Cuando vas restando y compruebas que el índice es positivo siempre suele ser más efectivo para la CPU, ya que según vas restando el índice al llegar a negativo automáticamente se activa el flag interno de la CPU de resultado negativo, y la comparación solo tiene que consultar ese flag, mientras que si comparas el índice contra un índice tope en cada iteración tiene que hacer la resta y comprobar que sea cero.
masteries
06/09/2013, 11:32
Gracias chavalotes, la interpolación bilineal y su formulote los mire, pero también tiene que ejecutarse a 50 cuadros por segundo en el Intel Atom a 600 Mhz de un PC-104, al mismo tiempo que maneja sus tarjetitas de entrada salida para controlar un "porrón" de actuadores y sensores de todo tipo. La matriz original es de 16x16 y habrá que inventarse píxeles hasta 256x256 al menos.
Jurk: Probaré el tuyo a ver como queda una matriz tal que esta,
6 1 12
1 16 1
1 2 1
Primero tienes que crear la imagen ampliada, lo has hecho?
Fichero adjunto mejorando legibilidad y quiza rendimiento.... o no
Mirate este masteries
@ masteries, cambiale las ctes a los tamaños que desees,
-----Actualizado-----
masteries he probado tu matriz, y al triplicarle el tamaño obtengo esto, no se si es lo que buscas:
6 1 12
1 16 1
1 2 1
6 6 6 1 1 1 12 12 12
6 6 6 1 1 1 12 12 12
6 6 6 1 1 1 12 12 12
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 2 2 2 1 1 1
1 1 1 2 2 2 1 1 1
1 1 1 2 2 2 1 1 1
6 6 4 3 1 5 8 12 12
6 6 4 3 1 5 8 12 12
4 4 5 5 6 7 8 8 8
3 3 5 8 11 9 7 5 5
1 1 6 11 16 11 6 1 1
1 1 4 8 11 8 4 1 1
1 1 3 5 7 5 3 1 1
1 1 1 2 2 2 1 1 1
1 1 1 2 2 2 1 1 1
Press any key to continue . . .
masteries
08/09/2013, 19:03
@ masteries, cambiale las ctes a los tamaños que desees,
-----Actualizado-----
@masteries (http://www.gp32spain.com/foros/member.php?u=28729) he probado tu matriz, y al triplicarle el tamaño obtengo esto, no se si es lo que buscas:
6 1 12
1 16 1
1 2 1
6 6 6 1 1 1 12 12 12
6 6 6 1 1 1 12 12 12
6 6 6 1 1 1 12 12 12
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 2 2 2 1 1 1
1 1 1 2 2 2 1 1 1
1 1 1 2 2 2 1 1 1
6 6 4 3 1 5 8 12 12
6 6 4 3 1 5 8 12 12
4 4 5 5 6 7 8 8 8
3 3 5 8 11 9 7 5 5
1 1 6 11 16 11 6 1 1
1 1 4 8 11 8 4 1 1
1 1 3 5 7 5 3 1 1
1 1 1 2 2 2 1 1 1
1 1 1 2 2 2 1 1 1
Press any key to continue . . .
Muchas gracias Jurk, el efecto logrado es muy bueno; lo probaré porque se le ve muy efectivo y simple. Llegaré hasta multiplicar por 16 el tamaño.
Te mostraré los resultados en breve.
Edito: Acabo de leer el código y ha quedado genial, son cálculos bastante sencillos dentro de bucles for, por lo que al contener tan poco código máquina, se ejecuta directamente desde la caché.
Mañana mismo lo pintaré con SDL, contar con Señores como ustedes da gusto. Si alguna vez tienes algún problema relativo a microcontroladores o sistemas en Tiempo-Real ya tienes a quién preguntar.
creo que de pics y 8051 ya controlo lo que tengo que controlar... pero se agradece la oferta igualmente! Lo de OS JIT (just in time) ya o tengo bastante oxidado-.... algun buen libro?
masteries
15/09/2013, 21:42
creo que de pics y 8051 ya controlo lo que tengo que controlar... pero se agradece la oferta igualmente! Lo de OS JIT (just in time) ya o tengo bastante oxidado-.... algun buen libro?
En lugar de pics y 8051 me refería a micros con CPU ARM y unidad de coma flotante.
Mira lo que se puede hacer con el modelo que vengo utilizando, es tan potente que puede improvisarse un adaptador de vídeo VGA 640x400x8 bit usando el Timer 1, es genial:
http://www.youtube.com/watch?v=ymGCeG9_6c0
Estoy adaptando esas librerías y demos gráficas para su uso en ambiente industrial, para interfaces de usuario y demás, la gente de momento está quedando muy contenta por no tener que llevar un portátil a cuestas.
Powered by vBulletin® Version 4.2.5 Copyright © 2025 vBulletin Solutions Inc. All rights reserved.