C++ Imagen类代码示例

void VistaFigAgrandable::redraw(){
	
	int tempAncho = EscalasDeEjes::getInstance()->getCantidadUnidadesFisicasX(1);
	if(orig==NULL || tempAncho!= escalaAnterior){
		delete orig;
		Imagen* temp = (Imagen*)(Contenedor::getMultimedia(fig->getID()));
		orig = temp->scaleImagen(EscalasDeEjes::getInstance()->getCantidadUnidadesFisicasX(fig->getDimension()->getAncho()/fig->getLargo()),EscalasDeEjes::getInstance()->getCantidadUnidadesFisicasY(fig->getDimension()->getAlto()));
		escalaAnterior = tempAncho;
		largo_anterior = -1;
	}

	if (largo_anterior != fig->getLargo()){
		delete imggrande;
		imggrande = new Imagen((orig->getAncho())*(this->fig->getLargo()),orig->getAlto());
		Uint32 aux = imggrande->atransparentar();
		largo_anterior = fig->getLargo();

		for(int i=0;i<fig->getLargo();i++){
			imggrande->dibujarImagen(orig,NULL,i*orig->getAncho(),0);
		}
		imggrande->atransparentar(aux);
	}

	delete rotada;
	rotada = imggrande->rotarImagen(fig->getDimension()->getAngulo());
	
	if (fig->traslucido) rotada->setTransparency(150);
	if(fig->superpuesta) rotada->pintarRojo();
}

int main(int argc, char **argv){
    
    char grises[500]="";   
    char ruta[300] = "imagenes/";
    char ima[100] = "";
    Imagen origen;

    cout<<"Diga el nombre de la imagen con la extension"<< endl;
    cin >> ima;

    strcat(ruta,ima);

    if (!origen.leerImagen(ruta)){
       cerr << "error leyendo "<< ruta << "\n";
       return 1;
    }
    int tama = (origen.filas()*origen.columnas())+1;

    char arteASCII[tama];

    cout<<"Inserta los caracteres: "<< endl;
    cin >> grises;

    cout << "\nLa imagen en arte ASCII es:\n";
    if(origen.aArteASCII(grises, arteASCII, tama))
        cout << arteASCII;
    else
        cout << "La conversión no ha sido posible" << endl;  

}

vector<Imagen> dividir (const Imagen &img, int n, int m) {
    vector<Imagen> resultado;

    int cols  = img.ancho() / n;
    int filas = img.alto() / m;

    int i = 0;

    while(i < img.alto()) {
        int j = 0;
        while(j < img.ancho()) {

            Imagen esta_imagen(filas, cols);

            int i_img = 0;
            while (i_img < filas) {
                int j_img = 0;
                while(j_img < cols) {
                    Pixel este_pixel = img.obtenerPixel(i + i_img, j + j_img);
                    esta_imagen.modificarPixel(i_img, j_img, este_pixel);

                    j_img++;
                }
                i_img++;
            }
            resultado.push_back(esta_imagen);
            j += cols;
        }
        i += filas;
    }

    return resultado;
}

	Imagen Imagen::operator+( Imagen &imagen){

		int filas, columnas;

		if( nfilas > imagen.filas())
			filas = nfilas;
		else
			filas = imagen.filas();
		columnas = ncolumnas + imagen.columnas();
		
		Imagen resultado(filas,columnas);
		
		

		for (int i = 0; i < nfilas; i++){
			for( int j = 0; j < ncolumnas; j++){
				resultado.datos[i][j] = datos[i][j];
				
			}
		}
		
		for (int i = 0; i < imagen.filas(); i++){
			for ( int j = 0; j < imagen.columnas(); j++){
				resultado.datos[i][j+ncolumnas] = imagen.datos[i][j];
				
			}
		}
		
		return resultado;
	}

bool ocultar(Imagen &imagen, char cadena[]){
	int tama_ima = imagen.filas() * imagen.columnas();
	int tama_mens=strlen(cadena);
	int contador=0;

	if( (tama_mens +1) *8 > tama_ima){
		cerr << "La cadena es demasiado larga" << endl; // cerr
		return false;
	}else{
		for (int i =0;  i <= tama_mens; i++){
			for(int j=7; j>=0; j--){
				bool bit = get(cadena[i],j);
				byte byte_imagen = imagen.getPos(contador);
				if(bit){
					on(byte_imagen,0);
					imagen.setPos(contador,byte_imagen);
				}else{
					off(byte_imagen,0);
					imagen.setPos(contador,byte_imagen);
				}
				contador++;
			}
		}
		return true;		
	}
}

int main(int argc,   char * argv[])
{
  
      if(argc != 2)
      {
        cout << "Error en el número de argumentos." << endl;
        cout << "Forma de ejecución: " << endl;
        cout << "revelar salida.pgm > resultado.txt" << endl;
      }
      else
      {
        TipoImagen imag;
        int filas, columnas, Tamimagen;
        bool resultado,lectura;
        char cad[1000000/8];
        imag = LeerTipoImagen(argv[1],filas,columnas);
        Imagen img;
        if(imag == IMG_PGM)
           {
             lectura = img.LeerImagen(argv[1]);
             Tamimagen = filas*columnas;
             resultado = Revelar(img.Getvector(), cad, Tamimagen);
             cout << cad << endl;
           }
        else
           {
               cout << "Error en el formato de la imagen, tiene que ser PGM" << endl;
           }
      }
}

/**
   Crear un programa arteASCII que pida al usuario el nom-
   bre de la imagen de entrada, el conjunto de caracteres para realizar la
   ́ y escriba en pantalla la imagen convertida a arte ASCII
 */
int main(){
        const int TAMANIO_MAX = 500*500;
        char nombreFichero [100];
        char nombreSalida [100];
        //char arteASCII[TAMANIO_MAX]; // 4500 + el \0
        const int maxlong =TAMANIO_MAX;

        cout<<"\nIntroduzca el nombre de la imagen de entrada."<<endl;
        cout<<"\nSi la imagen no esta en este directorio introducir en el formato: directorio/nombreImagen.extension"<<endl;
        cin.getline(nombreFichero,99);

        Imagen origen;

        // Leer la imagen gio.pgm
        if (!origen.leerImagen(nombreFichero)) {
                cerr << "error leyendo imagenes/"<<nombreFichero<<"\n";
                return 1;
        }

        //Leemos el nombre del fichero de salida
        cout<<"\nIntroduzca el nombre del fichero de salida"<<endl;
        cin.getline(nombreSalida,99);
        if(origen.leeraArteASCII("grises.txt",nombreSalida,maxlong))
                cout << "\nFicheros creados correctamente, busque los : "<<nombreSalida<<".txt"<<endl;
        else
                cout << "La conversion no ha sido posible" << endl;

}

void marcaSegunSeamV(Imagen & LumMargenV, Imagen & BiR, Imagen & BiG, Imagen & BiB)
{
     //Marcamos con valores fuera de rango el seam en la imagen LumMargenVEscogido
	find_v_seam(LumMargenV);
	
	unsigned int col;
	
	for(unsigned int row = 0; row < LumMargenV.fils(); row++)
	{
		col = 0;
		while(LumMargenV(row, col) < 10E20) //10E20: valor fuera de rango.
		{
			BiR(row, col) = 10E20;
			BiG(row, col) = 10E20;
			BiB(row, col) = 10E20;
			col++;
			
			if(col == LumMargenV.cols()) //Debugger
			{
				fprintf(stderr,"En ''marcaSegunSeamV()'' se pasa de largo!!!\n");
				exit(1);
			}
		
		}
	}
}

int main(){
    char grises[] = "@#%xo;:,. ";

    char arteASCII[4501]; // 4500 + el \0

    Imagen origen;

    // Leer la imagen gio.pgm
    if (!origen.leerImagen("imagenes/gio.pgm")){
	   cerr << "error leyendo imagenes/gio.pgm\n";
	   return 1;
    }

    cout << "\nLa imagen en arte ASCII es:\n";
    if(origen.aArteASCII(grises, arteASCII, 4500))
        cout << arteASCII;
    else
        cout << "La conversion no ha sido posible" << endl;

    cout << "Ahora Forzamos que no quepa. Debe aparecer un mensaje de error\n";
    if(origen.aArteASCII(grises, arteASCII, 4199))
        cout << arteASCII;
    else
        cout << "La conversion no ha sido posible" << endl;

    return 0;
}

void TestImagenDAO::getById(ImagenDAO* dao, unsigned int id){
	Imagen buffer = dao->getImgById(id);
	std::cout << "**** getById -" << id << "-" << std::endl;
	if(buffer.getID() != 0)	//el ID 0 indica informacion invalida
		print(&buffer);
	else
		std::cout << "**** NULO" << std::endl;
}

Imagen::Imagen(Imagen & im2)
{
  dim[0]=im2.fils();
  dim[1]=im2.cols();
  int largo=dim[0]*dim[1];
  datos=new double[largo];
  for(int i=0; i< largo; i++)
    datos[i]=im2.datos[i];
}

void graficaPuntos(double xi, double yi, double xf, double yf, double x[], double y[], int n,Color c, Imagen& I){
	double dx = (xf - xi);
	double dy = (yf - yi);
	for(int i=1;i<n;i++){
		int x1 = (int)floor((x[i-1]-xi)*I.columnas()/dx);
		int y1 = (int)floor((y[i-1]-yi)*I.filas()/dy);
		int x2 = (int)floor((x[i]-xi)*I.columnas()/dx);
		int y2 = (int)floor((y[i]-yi)*I.filas()/dy);
		primitivas::linea(I, x1,y1,x2,y2,c);
	}
}

int main(int argc, char * argv[]) {
    if (argc!=4) {
        cout<<"Los parametros son :"<<endl;
        cout<<"1. La imagen de entrada"<<endl;
        cout<<"2. El angulo de rotación (en grados)"<<endl;
        cout<<"3. El nombre de la imagen de salida"<<endl;
        return 0;
    }
    Imagen I;
    double angulo = atof(argv[2]);
    angulo = angulo*(M_PI)/180; //Pasamos el angulo a radianes
    I.leer(argv[1]).rotar(angulo).escribir(argv[3],"PPM");
}

int main(){
	char archivo_grises[255];
	char archivo_salida[255];
	char grises[100];
	
	const int TAM=100000;
	
    char arteASCII[TAM]; 
       
    Imagen origen;
    char nombre_imagen[255];
	
	cout << "Introduce el nombre de la imagen .pgm: " << endl;  
	cin >> nombre_imagen;
	
	cout << "Introduce el fichero de grises: " << endl;  
	cin >> archivo_grises;
	
	cout << "Introduce el fichero de salida: " << endl;  
	cin >> archivo_salida;
	
	if (!origen.leerImagen(nombre_imagen)){
	   cerr << "error leyendo " << nombre_imagen << " \n";
	   return 1;
    }
	
	string linea;
	int num_grises;
	ifstream fentrada;
	ofstream fsalida;
	fentrada.open(archivo_grises);
	if(fentrada){
		getline(fentrada,linea);				//Ignorar primera linea
		fentrada >> num_grises;
		for(int x=1; x<=num_grises; x++){
			fentrada>>grises;
		    if(origen.aArteASCII(grises, arteASCII, TAM)){
		    	char nombre_aux[255];
		    	//strcpy(nombre_aux,archivo_salida);
		    	sprintf(nombre_aux, "%s%d%s", archivo_salida,x,".txt");
		    	//strcat(nombre_aux,".txt");
				fsalida.open(nombre_aux);
				fsalida << arteASCII;
				fsalida.close();
			}else{
				cout << "La conversión " << x << " no ha sido posible" << endl;  
			}
		}
		fentrada.close();
	}else{

	void Imagen::copia(Imagen & imagen){
		if(datos==NULL)
			destruir();
		nfilas = imagen.filas();
		ncolumnas = imagen.columnas();
		datos = new byte*[nfilas];
		datos[0]=new byte[nfilas*ncolumnas];
		for (int i=1; i < nfilas; i++){
			datos[i] = datos[i-1] + ncolumnas;
		} 
		for(int i=0;i<nfilas;i++)
			for(int j=0;j<ncolumnas;j++)
				datos[i][j]=imagen.get(i,j);
	}