violacion de segmento complicado

rucal · #1 (**permalink**) 20/01/2013, 19:41

Antes que nada pongo el codigo. aunque lo voy a poner casi todo, quizas no sea necesario tanto para ayudarme con mi problema.

imagen.h

Código:

#ifndef IMAGEN_H_
#define IMAGEN_H_

#include <iostream>
#include <cassert>
#include "imagenES.h"

template <class T>
class Imagen{
  
  T** pixeles; ///< Vector de tipo T que almacena los píxeles de una imagen.
  int filas; ///< Número de filas de la imagen.
  int col; ///< Número de columnas de la imagen.

  void Copiar(const Imagen<T> &orig, Imagen<T> &dest);
  void Borrar(Imagen<T> &dest);
  
public:
  Imagen() { filas=col=0;pixeles=0;}
  Imagen(int f, int c);
  Imagen(int f, int c, T *pixeles);
  void getVector(T* &vector);
  Imagen(const Imagen<T> &img);
  ~Imagen();
  Imagen<T> & operator=(const Imagen<T> &img);
  int num_filas() const {return filas; };
  int num_columnas() const {return col; };
  T & operator()(int fila, int col){ return pixeles[fila][col]; }
  const T & operator()(int fila, int col) const { return pixeles[fila][col]; }
  
  
  
  /*************************************************************/
  /*                   CLASE ITERATOR_FILA                     */
  /*************************************************************/

  class iterator_fila{
	  T **p;
	  int ncol;
	  
	public:
	  iterator_fila() { p=0; ncol=0; }
	  iterator_fila(const iterator_fila &it): p(it.p) {}
	  ~iterator_fila() {}
	  T* & operator*() const { assert(p!=0); return *p; }
	  bool operator==(const iterator_fila &it){ return p==it.p; }
	  bool operator!=(const iterator_fila &it){ return p!=it.p  ; }
	  iterator_fila& operator=(const iterator_fila& orig) { p=orig.p; ncol=orig.ncol; return *this; }
	  iterator_fila& operator++() { assert(p!=0); p++; return *this; }
	  iterator_fila& operator--() { assert(p!=0); p--; return *this; }
	  
	  
	  
	  /*************************************************************/
	  /*                   CLASE ITERATOR_COLUMNA		       */
	  /*************************************************************/	  
	  
	  class iterator_columna{
		  T *q;
		public:
		  iterator_columna():q(0) {}
		  iterator_columna(const iterator_columna& it): q(it.q) {}
		  ~iterator_columna() {}
		  T & operator*() const { assert(q!=0); return *q; }
		  bool operator==(const iterator_columna &it) { return q==it.q; }
		  bool operator!=(const iterator_columna &it) { return q!=it.q; }
		  iterator_columna& operator=(const iterator_columna &orig) { q=orig.q; return *this; }
		  iterator_columna& operator++() { assert(q!=0); q++; return *this; }
		  iterator_columna& operator--() { assert(q!=0); q--; return *this; }
		  friend class Imagen<T>;
		  friend class Imagen<T>::iterator_fila;
		  
	  }; // FIN iterator_columna
	  iterator_columna begin();
	  iterator_columna end();
	  
	  friend class Imagen<T>;
	  friend class Imagen<T>::iterator_fila::iterator_columna;
	 
  }; // FIN iterator_fila
  
  
  
  /*************************************************************/
  /*                   CLASE CONST_ITERATOR_FILA               */
  /*************************************************************/

  class const_iterator_fila{
	  T **p;
	  int ncol;
	  
	public:
	  const_iterator_fila() { p=0; ncol=0; }
	  const_iterator_fila(const const_iterator_fila &it):p(it.p) {}
	  ~const_iterator_fila() {}
	  const T* & operator*() const { assert(p!=0); return *p; };
	  bool operator==(const const_iterator_fila &it){ return p==it.p; }
	  bool operator!=(const const_iterator_fila &it){ return p!=it.p; }
	  const_iterator_fila& operator=(const const_iterator_fila& orig) { p=orig.p; ncol=orig.ncol; return *this; }
	  const_iterator_fila& operator++() { assert(p!=0); p++; return *this; }
	  const_iterator_fila& operator--() { assert(p!=0); p--; return *this; }
	  
	  
	  
	  /*************************************************************/
	  /*                   CLASE CONST_ITERATOR_COLUMNA	       */
	  /*************************************************************/	  

	  class const_iterator_columna{
		  T *q;
		public:
		  const_iterator_columna():q(0) {}
		  const_iterator_columna(const const_iterator_columna& it):q(it.q) {}
		  ~const_iterator_columna() {}
		  const T & operator*()const { assert(q!=0); return *q; }
		  bool operator==(const const_iterator_columna &it) { return q==it.q; }
		  bool operator!=(const const_iterator_columna &it) { return q!=it.q; }
		  const_iterator_columna& operator=(const const_iterator_columna &orig) { q=orig.q; return *this; }
		  const_iterator_columna& operator++() { assert(q!=0); q++; return *this; }
		  const_iterator_columna& operator--() { assert(q!=0); q--; return *this; }
		  
		  friend class Imagen<T>;
		  friend class Imagen<T>::const_iterator_fila;
		  
	  }; // FIN const_iterator_columna
	  const_iterator_columna begin() const;
	  const_iterator_columna end() const;

	  friend class Imagen<T>;
	  friend class Imagen<T>::const_iterator_fila::const_iterator_columna;	  
  }; // FIN const_iterator_fila
  iterator_fila begin();
  iterator_fila end();
  const_iterator_fila begin() const; 
  const_iterator_fila end() const;
    
};

#include "imagen.tpp"
#endif

imagen.tpp

Código:

/*************************************************************/
/*                   IMPLEMENTACIÓN                          */
/*************************************************************/
#include <iostream>
using namespace std;
template <class T>
void Imagen<T>::Copiar(const Imagen<T> &orig, Imagen<T> &dest){

  dest.filas=orig.filas;
  dest.col=orig.col;
  
  dest.pixeles=new T*[dest.filas];
  
  dest.pixeles[0]=new T[dest.filas*dest.col];
  
  for(int i=0;i<dest.filas*dest.col;i++)
    dest.pixeles[0][i]=orig.pixeles[0][i];
  
  for(int i=1;i<dest.filas;i++)
    dest.pixeles[0]=dest.pixeles[i-1]+dest.col;
}

template <class T>
void Imagen<T>::Borrar(Imagen<T> &dest){
  delete[] dest.pixeles[0];
  delete[] dest.pixeles;
  dest.filas=dest.col=0;
  dest.pixeles=0;
}

/*************************************************************/
/*              Funciones asociadas a la clase Imagen        */
/*************************************************************/

template <class T>
Imagen<T>::Imagen(int f, int c){
  
  this->pixeles=new T*[f];
  
  this->pixeles[0]=new T[f*c];
  
  for(int i=1;i<f;i++)
    pixeles[i]=pixeles[i-1]+c;
  
  filas=f;
  col=c;
  
}

template <class T>
 Imagen<T>::Imagen(int f, int c,T *pixeles){
   this->filas=f;
   this->col=c;
   this->pixeles=new T*[f];
   this->pixeles[0]=new T[f*c];
   
   for(int i=0;i<f*c;i++)
     this->pixeles[0][i]=pixeles[i];
   
   for(int i=1;i<f;i++)
     this->pixeles[i]=this->pixeles[i-1]+c;
   
 }

template <class T>
void Imagen<T>::getVector(T* &vector) {
  vector=new T[filas*col];
  for(int i=0;i<filas*col;i++)
    vector[i]=pixeles[0][i];


template <class T>
Imagen<T>::Imagen(const Imagen<T> &img){
  
  Copiar(img,*this);
  
}

template <class T>
Imagen<T>::~Imagen(){
  Borrar(*this);
}

//OPERATOR IGUAL CLASE IMAGEN
template <class T>
Imagen<T> & Imagen<T>::operator=(const Imagen<T> &img){
  if(this!=&img){
     Borrar(*this);
     Copiar(img,*this);
  }
  
  return *this;

}

/*************************************************************/
/*              BEGIN Y END                                  */
/*************************************************************/

template <class T>
typename Imagen<T>::iterator_fila::iterator_columna Imagen<T>::iterator_fila::begin(){
  
  typename Imagen<T>::iterator_fila::iterator_columna it;
  
  it.q=*p;
  return it;
  
}

template <class T>
typename Imagen<T>::iterator_fila::iterator_columna Imagen<T>::iterator_fila::end(){
  
  typename Imagen<T>::iterator_fila::iterator_columna it;
  
  it.q=(*p+ncol);

  return it;
  
}
  
template <class T>
typename Imagen<T>::iterator_fila Imagen<T>::begin(){
    

  typename Imagen<T>::iterator_fila it;
  
  it.p=pixeles;
  it.ncol=col;
  return it;
  
}

template <class T>
typename Imagen<T>::iterator_fila Imagen<T>::end(){
  
  typename Imagen<T>::iterator_fila it;
  
  it.p=(&pixeles[0]+filas);

  return it;
  
}

template <class T>
typename Imagen<T>::const_iterator_fila::const_iterator_columna Imagen<T>::const_iterator_fila::begin() const{
  
  typename Imagen<T>::const_iterator_fila::const_iterator_columna it;
  
  it.q=*p;
  return it;
  
}

template <class T>
typename Imagen<T>::const_iterator_fila::const_iterator_columna Imagen<T>::const_iterator_fila::end() const{
  
  typename Imagen<T>::const_iterator_fila::const_iterator_columna it;
  
  it.q=(*p+ncol);

  return it;
  
}
  
template <class T>
typename Imagen<T>::const_iterator_fila Imagen<T>::begin() const{
    

  typename Imagen<T>::const_iterator_fila it;
  
  it.p=pixeles;
  it.ncol=col;
  return it;
  
}

template <class T>
typename Imagen<T>::const_iterator_fila Imagen<T>::end() const{
  
  typename Imagen<T>::const_iterator_fila it;
  
  it.p=(&pixeles[0]+filas);

  return it;
  
}

rucal · #2 (**permalink**) 20/01/2013, 19:41

procesamiento.tpp

Código:

#include "procesamiento.h"
#include <iostream>

template <class T>
void Umbralizar(const Imagen<T> &origen, Imagen<T> &destino, const T &t1, const T &t2/*, T* &v*/){
  Imagen<T> aux(origen.num_filas(),origen.num_columnas());
  typename Imagen<T>::const_iterator_fila it1_f;
  typename Imagen<T>::const_iterator_fila::const_iterator_columna it1_c;
  typename Imagen<T>::iterator_fila it2_f;
  typename Imagen<T>::iterator_fila::iterator_columna it2_c;
  for(it1_f=origen.begin(),it2_f=aux.begin();it1_f!=origen.end();++it1_f,++it2_f){
    for(it1_c=it1_f.begin(),it2_c=it2_f.begin();it1_c!=it1_f.end();++it1_c,++it2_c){
      if(*it1_c>t1 && *it1_c<t2){
	*it2_c=*it1_c;
      }
      else
	*it2_c=255;
    }
  }
  destino=aux;
    
}

main

Código:

#include <iostream>
#include <cstring>
#include <cstdlib>

#include <imagenES.h>
#include "imagen.h"
#include "procesamiento.h"

using namespace std;

int main (int argc, char *argv[]){
 
    char *origen, *destino; // nombres de los ficheros
 
 
 
    unsigned char *image;
    int nf, nc;//, npixeles; // Num. de filas y columnas de las imagenes
 
   // Comprobar validez de la llamada
    if (argc != 3){
      cerr << "Error: Numero incorrecto de parametros.\n";
      cerr << "Uso: negativo <FichImagenOriginal> <FichImagenDestino>\n";
      exit (1);
    }
 
    origen  = argv[1];
    destino = argv[2];

    
   cout << endl;
   cout << "Fichero origen: " << origen << endl;
   cout << "Fichero resultado: " << destino << endl;
 
   // Leer la imagen del fichero de entrada
   
    image = LeerImagenPGM (origen, nf, nc);
    if (!image){
      cerr << "Error: No pudo leerse la imagen." << endl;
      cerr << "Terminando la ejecucion del programa." << endl;
      exit (1);
    }

    Imagen<unsigned char> img(nf,nc,image);
    Imagen<unsigned char> dest(nf,nc,image);
    
   // Mostrar los parametros calculados por LeerImagenPGM()
   cout << endl;
   cout << "Dimensiones de " << origen << ":" << endl;
   cout << "   Imagen   = " << nf  << " filas x " << nc << " columnas " << endl;
   
   Umbralizar(img,dest,(unsigned char)100,(unsigned char)200);

   if (EscribirImagenPGM (destino, image, nf, nc))
     cout  << "La imagen se guardo en " << destino << endl;
   else{
     cerr << "Error: No pudo guardarse la imagen." << endl;
     cerr << "Terminando la ejecucion del programa." << endl;
     exit (2);
   }
 
//   // Liberar la imagen
   delete [] image;
    
    return (0);
}

el compilador no da ningun error. el problema es una violacion de segmento en la funcion umbralizar. cuando entra en el operator= al intentar copiar aux en destino. probando mucho he averiguado que el problema esta al intentar borrar pixeles[0] en la funcion Borrar que esta usando el operator=.

tambien he comprobado que el error no esta en borrar pixeles[0]. tambien me da problemas al intentar acceder a pixeles[0] en el operator= justo antes de intentar utilizar la funcion borrar. tambien he comprobado que cuando se accede a la funcion borrar desde el destructor no hay problemas. asi que el problema esta en el operator=.

yo el codigo lo veo bien, pero esta claro que hay algo que se me escapa. no he tenido mas remedio que pedir ayuda aqui porque llevo dias haciendo pruebas y no veo donde esta el error.

espero que me podais ayudar, gracias!!

sam90 · #3 (**permalink**) 21/01/2013, 17:27

No analise todo el codigo pero hay cosas que no tienen sentido:
Por ejemplo si una imagen tiene filas y columnas tu solo estas usando un fila de la imagen. Mira lo siguiente:
dest.pixeles=new T*[dest.filas];
dest.pixeles[0]=new T[dest.filas*dest.col];

Reservaste memoria para tantas filas, pero luego solo reservas memoria para la primer fila. Eso deberia ser:

dest.pixeles=new T*[dest.filas];
for(i=0 ; i < dest.filas ; i++ )dest.pixeles[i]=new T[dest.col];

Otra cosa que para mi te estas haciendo lio. No entiendo poruqe el borrar tiene como un argumento otra imagen. La idea si usas clases que el borrar sea un metodo de la propia clase y al invocarlo borre la propia imagen.
No que una imagen borre a otra.

Lo mismo para copiar. Vos Copias de A a B pero necesitarias a C para que haga de intermediario.

Mas tarde voy a probar el codigo que pusiste.

rucal · #4 (**permalink**) 21/01/2013, 18:14

gracias por responder!!

la idea de hacerlo asi, es para que quede de esta forma:

ya he utilizado esta representacion de matriz en otras ocasiones. de hecho haces unos meses hice otra version de esta misma clase Imagen (sin iteradores ni templates). utilice esta misma representacion y funcionaba.

lo que dices de las funciones Borrar y Copiar, sinceramente ahora no sabria decirte porque lo he hecho asi. estoy lo hice practicamente al principio de todo y has surgido tantos problemas que ya ni me acuerdo. pero creo recordar que en una clase (sin ninguna relacion con esta) que me facilitaron mis profesores hicieron algo parecido.

si quieres probar mi codigo (cosa que realmente agradezco, porque va a ser mucho lio solo para ayudarme) aun faltan algunos archivos:

imagenES.h

Código:

#ifndef _IMAGEN_ES_H_
#define _IMAGEN_ES_H_

enum TipoImagen {IMG_DESCONOCIDO, IMG_PGM, IMG_PPM};

TipoImagen LeerTipoImagen (const char *nombre);
unsigned char *LeerImagenPPM (const char *nombre, int& fils, int& cols);
bool EscribirImagenPPM (const char *nombre, const unsigned char *datos,const int fils, const int cols);
unsigned char *LeerImagenPGM (const char *nombre, int& fils, int& cols);
bool EscribirImagenPGM (const char *nombre, const unsigned char *datos, const int fils, const int cols);

#endif

imagenES.cpp

Código:

#include <fstream>
#include <string>

#include <imagenES.h>

using namespace std;

TipoImagen LeerTipo(ifstream& f){
  char c1,c2;
  TipoImagen res= IMG_DESCONOCIDO;

  if (f){
    c1=f.get();
    c2=f.get();
    if (f && c1=='P')
      switch (c2) {
        case '5': res= IMG_PGM; break;
        case '6': res= IMG_PPM; break;
        default: res= IMG_DESCONOCIDO;
      }
  }
  return res;
}

// _____________________________________________________________________________

TipoImagen LeerTipoImagen(const char *nombre){
  ifstream f(nombre);
  return LeerTipo(f);
}


// _____________________________________________________________________________

char SaltarSeparadores (ifstream& f){
  char c;
  do{
    c= f.get();
  } while (isspace(c));
  f.putback(c);
  return c;
}

// _____________________________________________________________________________

bool LeerCabecera (ifstream& f, int& fils, int& cols){
    int maxvalor;
    string linea;
    while (SaltarSeparadores(f)=='#')
      getline(f,linea);
    f >> cols >> fils >> maxvalor;
    
    if (/*str &&*/ f && fils>0 && fils<5000 && cols>0 && cols<5000){
        f.get(); // Saltamos separador
        return true;
    }
    else 
      return false;
}



// _____________________________________________________________________________

unsigned char *LeerImagenPPM (const char *nombre, int& fils, int& cols){
  unsigned char *res=0;
  fils=0;
  cols=0;
  ifstream f(nombre);
  
  if (LeerTipo(f)==IMG_PPM){
    if (LeerCabecera (f, fils, cols)){
        res= new unsigned char[fils*cols*3];
        f.read(reinterpret_cast<char *>(res),fils*cols*3);
        if (!f){
          delete[] res;
          res= 0;
        }
    }
  }
  return res;
}

// _____________________________________________________________________________

unsigned char *LeerImagenPGM (const char *nombre, int& fils, int& cols){
  unsigned char *res=0;
  fils=0;
  cols=0;
  ifstream f(nombre);
  
  if (LeerTipo(f)==IMG_PGM){
    if (LeerCabecera (f, fils, cols)){
      res= new unsigned char[fils*cols];
      f.read(reinterpret_cast<char *>(res),fils*cols);
      if (!f){
        delete[] res;
        res= 0;
      }
    }
  }
  return res;
}

// _____________________________________________________________________________

bool EscribirImagenPPM (const char *nombre, const unsigned char *datos, 
                        const int fils, const int cols){
  ofstream f(nombre);
  bool res= true;
  
  if (f){
    f << "P6" << endl;
    f << cols << ' ' << fils << endl;
    f << 255 << endl;
    f.write(reinterpret_cast<const char *>(datos),fils*cols*3);
    if (!f)
      res=false;
  }
  return res;
}
// _____________________________________________________________________________

bool EscribirImagenPGM (const char *nombre, const unsigned char *datos, 
                        const int fils, const int cols){
  ofstream f(nombre);
  bool res= true;
  
  if (f){
    f << "P5" << endl;
    f << cols << ' ' << fils << endl;
    f << 255 << endl;
    f.write(reinterpret_cast<const char *>(datos),fils*cols);
    if (!f)
      res=false;
  }
  return res;
}


/* Fin Fichero: imagenES.cpp */

procesamiento.h

Código:

#ifndef PROCESAMIENTO_H_
#define PROCESAMIENTO_H_

#include "imagen.h"

template <class T>
void Umbralizar(const Imagen<T> &origen, Imagen<T> &destino, const T &t1, const T &t2/*,T* &v*/);

#include "procesamiento.tpp"
#endif

el modulo imagenES se utiliza para la entrada y salida de imagenes (deben ser pgm). me la dieron ya implementada mis profesores.

Malenko · #5 (**permalink**) 22/01/2013, 10:35

Cita:

Iniciado por rucal

el modulo imagenES se utiliza para la entrada y salida de imagenes (deben ser pgm). me la dieron ya implementada mis profesores.

Que ficheros del código que has puesto te han dado los profesores y cual has hecho tú?

Es yo tengo serias dudas de que la inicialización del puntero de pixeles esté realizada de forma correcta. Entiendo que queires representar mediante un array lineal un array bidimensional y creo que no es correcta la inicialización. Quizás es que llevo ya muchas horas programando por hoy, o que yo lo haría de otra forma :)

rucal · #6 (**permalink**) 22/01/2013, 12:23

lo unico que no he hecho yo han sido los ficheros imagenES.h e imagenES.cpp

no digo que no este mal, pero me extrañaria porque como ya he dicho ya he utilizado esa inicializacion otras veces. aunque despues de tantas vueltas que le he dado ha esto ya no se que pensar.

como tengo prisa por solucionar esto, porque aun me queda para terminar lo que tengo que hacer, puse este mismo mensaje en otros foros. aqui he dado alguna informacion mas:

[URL="http://www.foro.lospillaos.es/violacion-de-segmento-complicado-vt12267.html"]http://www.foro.lospillaos.es/violacion-de-segmento-complicado-vt12267.html[/URL]

gracias de nuevo

rucal · #7 (**permalink**) 22/01/2013, 14:05

desde el principio solo he intentado arreglar el error que prodcuia la violacion de segmento. ni se paso por la cabeza cambiar la representacion. pero ahora viendo que tenia que seguir con mi practica y no encontraba solucion y sobretodo a vosotroshe cambiado la representacion al fin y ahora si me funciona correctamente.

no se que pudo causar el error, pero ahora no tengo tiempo de averiguarlo. antes de cambiar la representacion hice una copia de todos los ficheros asi que tengo los de la antigua representacion. en cuanto tenga tiempo intentare ver cual era el problema para no cometer el mismo error en el futuro (que seguro habia sido una tonteria).

gracias!!

rucal · #8 (**permalink**) 22/01/2013, 14:20

por cierto ya que estoy aprovecho para preguntar otra duda.

en otra asignatura nos dijeron que para realizar las practicas era mejor organizarlas en carpetas de esta forma:

practica
|__ makefile
|__ bin (para ejecutables)
|__ include (para los .h)
|__ src (para los .cpp)
|__ obj (para los .o)
|__ lib (para las librerias .a)
|__ doc (para la documentacion doxygen)
|__ datos (para los posibles datos que sean necesarios)

por entonces todavia no habiamos dado los templates, asi que no nos dijeron en que carpeta deberian ir. yo pensaba que deberia ir en src junto con los cpp pero al intentar compilar con make parecia no encontrar los tpp. asi que los puse en include con los h.

esta correcto asi?? porque deben estar os tpp en la misma carpeta que los .h??

Malenko · #9 (**permalink**) 22/01/2013, 14:24

Cita:

Iniciado por rucal

no se que pudo causar el error, pero ahora no tengo tiempo de averiguarlo. antes de cambiar la representacion hice una copia de todos los ficheros asi que tengo los de la antigua representacion. en cuanto tenga tiempo intentare ver cual era el problema para no cometer el mismo error en el futuro (que seguro habia sido una tonteria).

Pues es lo primero que tenías que hacer es saber porque te fallaba porque es "bastante evidente" y el objetivo de los ejercicios es aprender haciendolos, no que te dé una solución buena sin saber el porque.

rucal · #10 (**permalink**) 22/01/2013, 16:54

Cita:

Iniciado por rucal

no se que pudo causar el error, pero ahora no tengo tiempo de averiguarlo. antes de cambiar la representacion hice una copia de todos los ficheros asi que tengo los de la antigua representacion. en cuanto tenga tiempo intentare ver cual era el problema para no cometer el mismo error en el futuro (que seguro habia sido una tonteria).

gracias!!