• Viernes 8 de Noviembre de 2024, 19:39

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - javili

Páginas: [1]
1
C/C++ / Problema con "Segmentation Fault" en la libreria "Allegro"
« en: Viernes 4 de Mayo de 2012, 20:34 »
Hola, tengo un problema de lo que creo que es desbordamiento de memoria, con error "Segmentation Fault" de la libreria Allegro.

El fallo se produce en la función "CalcularZonas", creo que el problema esta en el "buffer", pero no estoy seguro. La verdad no creo que se pueda encontrar el por qué, pero si alguien se lo quiere tomar como un reto y quiere ayudarme, le estaria muy gratamente agradecido.

El codigo del programa es el seguiente:

Código: C++
  1. #include <iostream>
  2. #include "EasyBMP.h"
  3. #include "allegro.h"
  4.  
  5. #define X 740
  6. #define Y 570
  7. #define F 10000
  8.  
  9. using namespace std;
  10.  
  11. class Pixel
  12. {
  13.     public:
  14.     short int red;
  15.     short int green;
  16.     short int blue;
  17.     short int alfa;
  18.     unsigned int zona;
  19.     bool pas,prepas;
  20. };
  21.  
  22. class Relieve{
  23.     public:
  24.     bool frontera;
  25. };
  26.  
  27. void CargarImagen (Pixel CCD[X][Y])
  28. {
  29.     int i,j;
  30.  
  31.     BMP imagen;
  32.     imagen.ReadFromFile("m64.bmp");
  33.  
  34.     for(i=0;i<X;i++){
  35.         for(j=0;j<Y;j++){
  36.             CCD[i][j].red=(int) imagen(i,j)->Red;
  37.             CCD[i][j].green=(int) imagen(i,j)->Green;
  38.             CCD[i][j].blue=(int) imagen(i,j)->Blue;
  39.             CCD[i][j].alfa=(int) imagen(i,j) ->Alpha;
  40.             CCD[i][j].pas=false;
  41.             CCD[i][j].prepas=false;
  42.             CCD[i][j].zona=0;
  43.         }
  44.     }
  45. }
  46.  
  47. void GraficarCCD(Pixel array[X][Y])
  48. {
  49.     int i,j;
  50.  
  51.     for(i=0;i<X;i++){
  52.         for(j=0;j<Y;j++){
  53.             putpixel(screen,i,j,makeacol(array[i][j].red,array[i][j].green,array[i][j].blue,array[i][j].alfa));
  54.         }
  55.     }
  56. }
  57.  
  58.  
  59.  
  60. void GraficarMascara(Relieve Mascara[X][Y])
  61. {
  62.     int i,j;
  63.  
  64.     for(i=0;i<X;i++){
  65.         for(j=0;j<Y;j++){
  66.             if(Mascara[i][j].frontera)
  67.             putpixel(screen,i,j,makeacol(255,255,255,255));
  68.             else putpixel(screen,i,j,makeacol(0,0,0,0));
  69.         }
  70.     }
  71. }
  72.  
  73. void GraficarCCDMascara(Pixel CCD[X][Y],Relieve Mascara[X][Y])
  74. {
  75.     int i,j;
  76.  
  77.     for(i=0;i<X;i++){
  78.         for(j=0;j<Y;j++){
  79.             if(Mascara[i][j].frontera) putpixel(screen,i,j,makeacol(255,255,255,255));
  80.             else
  81.             {
  82.                 putpixel(screen,i,j,makeacol(CCD[i][j].red,CCD[i][j].green,CCD[i][j].blue,CCD[i][j].alfa));
  83.             }
  84.         }
  85.     }
  86.  
  87. }
  88.  
  89. int CalcularFrontera (Pixel CCD[X][Y],Relieve Mascara[X][Y])
  90. {
  91.     int i,j, corte, indice;
  92.  
  93.     cout<<"Por favor, escriba el valor de corte para calcular la frontera de luminosidad."<<endl<<endl;
  94.     do{
  95.         cout<<"Numero entre 0 y 255:  "<<endl;
  96.         cin>>corte;
  97.     }while(corte<-1 || corte>255);
  98.  
  99.     for(i=1;i<X-1;i++){
  100.         for(j=1;j<Y-1;j++){
  101.  
  102.             if(CCD[i][j].red>corte){
  103.                 if(CCD[i+1][j].red<corte || CCD[i-1][j].red<corte || CCD[i][j+1].red<corte || CCD[i][j-1].red<corte)
  104.                 {
  105.                     Mascara[i][j].frontera=true;
  106.                 }
  107.                 else Mascara[i][j].frontera=false;
  108.             }
  109.         }
  110.     }
  111.     GraficarMascara(Mascara);
  112.  
  113.     do{
  114.         cout<<"Pulse 1 para refrescar la pantalla"<<endl;
  115.         cout<<"Pulse 2 para superponer el filtro de saturacion a la imagen"<<endl;
  116.         cout<<"Pulse 3 para cambiar el limite de saturacion"<<endl;
  117.         cout<<"Pulse 4 para aceptar el limite de saturacion"<<endl;
  118.         cin>>indice;
  119.  
  120.         if(indice==1)
  121.         {
  122.             GraficarCCD(CCD);
  123.             GraficarMascara(Mascara);
  124.         }
  125.  
  126.         if(indice==2)
  127.         {
  128.             GraficarCCDMascara(CCD,Mascara);
  129.         }
  130.  
  131.         if(indice==3)
  132.         {
  133.             cout<<"Por favor, escriba el valor de corte para calcular la frontera de luminosidad."<<endl<<endl;
  134.             do{
  135.                 cout<<"Numero entre 0 y 255:  "<<endl;
  136.                 cin>>corte;
  137.             }while(corte<-1 || corte>255);
  138.  
  139.             for(i=0;i<X;i++){
  140.                 for(j=0;j<Y;j++){
  141.                     Mascara[i][j].frontera=false;
  142.                 }
  143.             }
  144.  
  145.             for(i=1;i<X-1;i++){
  146.                 for(j=1;j<Y-1;j++){
  147.  
  148.                     if(CCD[i][j].blue>corte){
  149.                         if(CCD[i+1][j].blue<corte || CCD[i-1][j].blue<corte || CCD[i][j+1].blue<corte || CCD[i][j-1].blue<corte)
  150.                         {
  151.                             Mascara[i][j].frontera=true;
  152.                         }
  153.                         else Mascara[i][j].frontera=false;
  154.                     }
  155.                 }
  156.             }
  157.             GraficarCCD(CCD);
  158.             GraficarMascara(Mascara);
  159.         }
  160.     }while(indice!=4);
  161.     return corte;
  162. }
  163.  
  164.  
  165. void CalcularZonas (Pixel CCD[X][Y],int corte_sat)
  166. {
  167.     class buf
  168.     {
  169.         public:
  170.         int k;
  171.         int l;
  172.     };
  173.  
  174.     int i,j,z,b,p,m;
  175.     int zonas=0;
  176.     z=0;
  177.     b=0;
  178.     buf buffer[F];
  179.     for(m=0;m<F;m++)
  180.     {
  181.         buffer[m].k=-1;
  182.         buffer[m].l=-1;
  183.     }
  184.  
  185.  
  186.  
  187.     for(i=0;i<X;i++)
  188.     {
  189.         for(j=0;j<Y;j++)
  190.         {
  191.  
  192.  
  193.             if(CCD[i][j].red>corte_sat && CCD[i][j].pas==false && CCD[i][j].prepas==false)
  194.             {
  195.                 z++;
  196.                 b=0;
  197.  
  198.                 CCD[i][j].zona=z;
  199.                 CCD[i][j].prepas=true;
  200.                 CCD[i][j].pas=true;
  201.  
  202.  
  203.                 if(CCD[i+1][j].red>corte_sat && CCD[i+1][j].prepas==false && CCD[i+1][j].pas==false)
  204.                 {
  205.                     buffer[b].k=i+1;
  206.                     buffer[b].l=j;
  207.                     b++;
  208.                     CCD[i+1][j].prepas=true;
  209.                 }
  210.                 if(CCD[i][j+1].red>corte_sat && CCD[i][j+1].prepas==false && CCD[i][j+1].pas==false)
  211.                 {
  212.                     buffer[b].k=i;
  213.                     buffer[b].l=j+1;
  214.                     b++;
  215.                     CCD[i][j+1].prepas=true;
  216.                 }
  217.                 if(CCD[i-1][j].red>corte_sat && CCD[i-1][j].prepas==false && CCD[i-1][j].pas==false)
  218.                 {
  219.                     buffer[b].k=i-1;
  220.                     buffer[b].l=j;
  221.                     b++;
  222.                     CCD[i-1][j].prepas=true;
  223.                 }
  224.                 if(CCD[i][j-1].red>corte_sat && CCD[i][j-1].prepas==false && CCD[i][j-1].pas==false)
  225.                 {
  226.                     buffer[b].k=i;
  227.                     buffer[b].l=j-1;
  228.                     b++;
  229.                     CCD[i][j-1].prepas=true;
  230.                 }
  231.                 if(CCD[i+1][j+1].red>corte_sat && CCD[i+1][j+1].prepas==false && CCD[i+1][j+1].pas==false)
  232.                 {
  233.                     buffer[b].k=i+1;
  234.                     buffer[b].l=j+1;
  235.                     b++;
  236.                     CCD[i+1][j+1].prepas=true;
  237.                 }
  238.                 if(CCD[i+1][j-1].red>corte_sat && CCD[i+1][j-1].prepas==false && CCD[i+1][j-1].pas==false)
  239.                 {
  240.                     buffer[b].k=i+1;
  241.                     buffer[b].l=j-1;
  242.                     b++;
  243.                     CCD[i+1][j-1].prepas=true;
  244.                 }
  245.                 if(CCD[i-1][j+1].red>corte_sat && CCD[i-1][j+1].prepas==false && CCD[i-1][j+1].pas==false)
  246.                 {
  247.                     buffer[b].k=i-1;
  248.                     buffer[b].l=j+1;
  249.                     b++;
  250.                     CCD[i-1][j+1].prepas=true;
  251.                 }
  252.                 if(CCD[i-1][j-1].red>corte_sat && CCD[i-1][j-1].prepas==false && CCD[i-1][j-1].pas==false)
  253.                 {
  254.                     buffer[b].k=i-1;
  255.                     buffer[b].l=j-1;
  256.                     b++;
  257.                     CCD[i-1][j-1].prepas=true;
  258.                 }
  259.  
  260.                 p=-1;
  261.  
  262.  
  263.                 do {
  264.                     p++;
  265.                     CCD[buffer[p].k][buffer[p].l].pas=true;
  266.                     CCD[buffer[p].k][buffer[p].l].zona=z;
  267.  
  268.                     buffer[p].k=-1;
  269.                     buffer[p].l=-1;
  270.  
  271.  
  272.                     if((CCD[(buffer[1+p].k)+1][buffer[1+p].l].red>corte_sat) && (CCD[(buffer[1+p].k+1)][buffer[1+p].l].prepas==false) && (CCD[(buffer[1+p].k+1)][buffer[1+p].l].pas==false))
  273.                     {
  274.                         buffer[b].k=buffer[1+p].k+1;
  275.                         buffer[b].l=buffer[1+p].l;
  276.                         b++;
  277.                     }
  278.                     if((CCD[(buffer[1+p].k)][buffer[1+p].l+1].red>corte_sat) && (CCD[(buffer[1+p].k)][buffer[1+p].l+1].prepas==false) && (CCD[(buffer[1+p].k)][buffer[1+p].l+1].pas==false))
  279.                     {
  280.                         buffer[b].k=buffer[1+p].k;
  281.                         buffer[b].l=buffer[1+p].l+1;
  282.                         b++;
  283.                     }
  284.                     if((CCD[(buffer[1+p].k)-1][buffer[1+p].l].red>corte_sat) && (CCD[(buffer[1+p].k)-1][buffer[1+p].l].prepas==false) && (CCD[(buffer[1+p].k)-1][buffer[1+p].l].pas==false))
  285.                     {
  286.                         buffer[b].k=buffer[1+p].k-1;
  287.                         buffer[b].l=buffer[1+p].l;
  288.                         b++;
  289.                     }
  290.                     if((CCD[buffer[1+p].k][(buffer[1+p].l)-1].red>corte_sat) && (CCD[buffer[1+p].k][(buffer[1+p].l)-1].prepas==false) && (CCD[(buffer[1+p].k)][(buffer[1+p].l)-1].pas==false))
  291.                     {
  292.                         buffer[b].k=buffer[1+p].k;
  293.                         buffer[b].l=buffer[1+p].l-1;
  294.                         b++;
  295.                     }
  296.                     if((CCD[(buffer[1+p].k)+1][(buffer[1+p].l)+1].red>corte_sat) && (CCD[(buffer[1+p].k)+1][(buffer[1+p].l)+1].prepas==false) && (CCD[(buffer[1+p].k)+1][(buffer[1+p].l)+1].pas==false))
  297.                     {
  298.                         buffer[b].k=buffer[1+p].k+1;
  299.                         buffer[b].l=buffer[1+p].l+1;
  300.                         b++;
  301.                     }
  302.                     if((CCD[(buffer[1+p].k)+1][(buffer[1+p].l)-1].red>corte_sat) && (CCD[(buffer[1+p].k)+1][(buffer[1+p].l)-1].prepas==false) && (CCD[(buffer[1+p].k)+1][(buffer[1+p].l)-1].pas==false))
  303.                     {
  304.                         buffer[b].k=buffer[1+p].k+1;
  305.                         buffer[b].l=buffer[1+p].l-1;
  306.                         b++;
  307.                     }
  308.                     if((CCD[(buffer[1+p].k)-1][(buffer[1+p].l)+1].red>corte_sat) && (CCD[(buffer[1+p].k)-1][(buffer[1+p].l)+1].prepas==false) && (CCD[(buffer[1+p].k)-1][(buffer[1+p].l)+1].pas==false))
  309.                     {
  310.                         buffer[b].k=buffer[1+p].k-1;
  311.                         buffer[b].l=buffer[1+p].l+1;
  312.                         b++;
  313.                     }
  314.                     if((CCD[(buffer[1+p].k)-1][(buffer[1+p].l)-1].red>corte_sat) && (CCD[(buffer[1+p].k)-1][(buffer[1+p].l)-1].prepas==false) && (CCD[(buffer[1+p].k)-1][(buffer[1+p].l)-1].pas==false))
  315.                     {
  316.                         buffer[b].k=buffer[1+p].k-1;
  317.                         buffer[b].l=buffer[1+p].l-1;
  318.                         b++;
  319.                     }
  320.  
  321.                 } while((buffer[1+p].k)!=-1);
  322.  
  323.             }
  324.             else
  325.             {
  326.                CCD[i][j].pas=true;
  327.             }
  328.  
  329.         }
  330.     }
  331.  
  332.  
  333.  
  334. cout<<z<<endl;
  335.  
  336. }
  337.  
  338. void GraficarCCDZona(Pixel array[X][Y])
  339. {
  340.     int i,j;
  341.  
  342.     for(i=0;i<X;i++){
  343.         for(j=0;j<Y;j++){
  344.             if(array[i][j].zona!=0)
  345.             {
  346.             putpixel(screen,i,j,makeacol(array[i][j].red,array[i][j].green,array[i][j].blue,array[i][j].alfa));
  347.             }
  348.             else{
  349.                 putpixel(screen,i,j,makeacol(0,0,0,0));
  350.             }
  351.         }
  352.     }
  353. }
  354.  
  355.  
  356. int main()
  357. {
  358.     string pausa;
  359.     int corte_sat;
  360.  
  361.     Pixel CCD[X][Y];
  362.     Relieve Mascara[X][Y];
  363.  
  364.     allegro_init();
  365.     set_color_depth(16);
  366.     set_write_alpha_blender();
  367.  
  368.     set_gfx_mode(GFX_AUTODETECT_WINDOWED,740,570,0,0);
  369.  
  370.     CargarImagen(CCD);
  371.     GraficarCCD(CCD);
  372.  
  373.     corte_sat=CalcularFrontera(CCD,Mascara);
  374.  
  375.     cin>>pausa;
  376.  
  377.     CalcularZonas(CCD,corte_sat);
  378.  
  379.     GraficarCCDZona(CCD);
  380.  
  381.     cin>>pausa;
  382.  
  383.  
  384.     allegro_exit();
  385.     return 0;
  386. }
  387.  
  388.  

2
C/C++ / Re:Leer bmp y convertirlo a matriz
« en: Miércoles 25 de Abril de 2012, 18:47 »
Tengo que usar bmp porque necesito imagenes sin comprimir, basicamente imagenes tomadas de observatorios astronomicos, que tienen la maxima calidad y con la estructura tipo RGB. He intentado probar y comprender el enlace que me has dejado pero no consigo ningun resultado al intentar leer el bmp en esa forma. Lo que he intentado es lo siguiente:

Código: C++
  1. #include <iostream>
  2. #include <fstream>
  3.  
  4. using namespace std;
  5.  
  6. int main()
  7. {
  8.     char c[100];
  9.     ifstream fich;
  10.  
  11.     fich.open("m64.bmp",ios::binary);
  12.  
  13.     while(!fich.eof()){
  14.         fich>>c;
  15.         cout<<c;
  16.     }
  17.     fich.close();
  18. }
  19.  
  20.  

El resultado son codigos ilegibles:
======<<<;;;:::99900000///////11... y cosas por el estilo. Este codigo es solo una prueba para ver lo que me da de salida el codigo segun esos parametros en fstream.

El resultado que espero es el que viene en la wiki:

                                       red    green   blue  alpha
FF 00 00 7F    que significa:  255    0         0      127     //tras pasarlo a decimal
00 FF 00 7F    que significa:    0     255      0      127
...

Esto es la estructura RGB y un numero adicional "alpha", obteniendo este resultado podria asociar a cada valor de la columna a mi Pixel[i,j].red, Pixel[i,j].green, Pixel[i,j].blue a cada Pixel de mi array, y asi obtener un array de objetos Pixel con toda la informacion del bmp.

Mi pregunta es en que forma, o que parametros tengo que aplicar a fstream para obtener esa codificacion.

Tambien si podriais decirme como obviar la cabecera para que solo obtenga los valores de los colores de la imagen bmp del pixel.

3
C/C++ / Leer bmp y convertirlo a matriz
« en: Martes 24 de Abril de 2012, 17:00 »
Hola, antes que nada enhorabuena por el foro ya que recién ingreso.

Quisiera hacerles una consulta acerca de un código que estoy creando para un proyecto de optica adaptativa.

He creado una classe pixel tal que:

Código: C++
  1. class Pixel
  2. {
  3.     public:
  4.     short int red;
  5.     short int green;
  6.     short int blue;
  7. };
  8.  

Lo que representa la estructura del color de un pixel en RGB siendo números enteros de 0 a 255, por lo que una imagen no será mas que un array de esos objetos "Pixel".
Lo que pretendo es cargar una imagen BMP mediante "fstream" para copiarlo a un array de objetos Pixel (que tiene la misma estructura que las imagenes BMP segun he visto en wiki: http://en.wikipedia.org/wiki/BMP_file_format). Y he visto que existe una cabecera que no se como tratar, ni como obtener la información que está cifrada en el BMP para poder manejarla y copiarla al array de objetos Pixel.
Si es posible no usar punteros, ni nada complicado mejor, ya que mi formación es de físico y mis conocimientos en programación son básicos, solo llego a usar clases y transferencia de archivos por fstream.

Si pudieran ayudarme se lo agradecería. Muchas Gracias.

Páginas: [1]