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");
}
void GaleriaImagenes::dividirYAgregar(const Imagen &imagen, int n, int m) {
int alto = imagen.alto();
int ancho = imagen.ancho();
if (alto % m == 0 && ancho % n == 0) {
vector<Imagen> dividida = dividir(imagen, n, m);
int i = 0;
while(i < dividida.size()) {
this->agregarImagen(dividida[i]);
i++;
}
}
}
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);
}
void Imagen::operator-=(Imagen & im2)
{
int fil2=im2.fils();
int col2=im2.cols();
if(dim[0]!=fil2 || dim[1]!=col2)
{
fprintf(stderr,"Diferentes dimensiones al restar imagenes \n");
return;
}
int largo=dim[0]*dim[1];
for(int i=0; i<largo; i++)
datos[i]-=im2.datos[i];
return;
}
void Imagen::operator*=(Imagen & im2)
{
int fil2=im2.fils();
int col2=im2.cols();
if(dim[0]!=fil2 || dim[1]!=col2)
{
fprintf(stderr,"Diferentes dimensiones al multiplicar imagenes \n");
return;
}
int largo=dim[0]*dim[1];
for(int i=0; i<largo; i++)
this->datos[i] *= (&im2)->datos[i];
return;
}
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;
I.LeerImagen(argv[1]);
double angulo=atof(argv[2]);
angulo = angulo*(M_PI)/180; //Pasamos el angulo radianes
//Imagen Iout=Rota(I,angulo);
//Iout.EscribirImagen(argv[3]);
}
// BACKTRACK
void backtrackV(Imagen &cE, int i, unsigned int j, Imagen & E)
{
if (i > 0)
{
// Aj = incremento de j
int Aj = minPosition(cE(i-1,j-1), cE(i-1,j), cE(i-1,j+1));
int f = i-1;
int c = j + Aj;
if(c == -1) c = 1;
if((unsigned int)c == cE.cols()) c = cE.cols()-2;
E(f, c) = 10E20;
backtrackV(cE, f, c, E);
}
}
unsigned int smallestH(Imagen &cumulativeE){
int f = cumulativeE.fils() -1; // last row
unsigned int h;
double min = 10E8; // valor de inicio
for (unsigned int j=0; j<cumulativeE.cols(); j++)
{
if (cumulativeE(f,j)<min)
{
h = j;
min = cumulativeE(f,j);
}
}
return h;
}
// finds the horizontal coordinate of the pixel in the last row with minimum value
unsigned int smallestV(Imagen &cumulativeE){
int c = cumulativeE.cols()-1; // last column
unsigned int v;
double min = 10E8; // valor de inicio
for (unsigned int i=0; i<cumulativeE.fils(); i++)
{
if (cumulativeE(i,c)<min)
{
v = i;
min = cumulativeE(i,c);
}
}
return v;
}
// BACKTRACK
void backtrackH(Imagen &cE, int i, unsigned int j, Imagen & E)
{
//cout<<"bt"<<i<<endl;
if (i > 0)
{
int c = i-1;
// Aj = incremento de j
int Aj = minPosition(cE(j-1,c), cE(j,c), cE(j+1,c));
int f = j + Aj;
if(f == -1) f = 1;
if((unsigned int)f == cE.fils()) f = cE.fils()-2;
E(f, c) = 10E20;
backtrackH(cE, c, f, E);
}
}
int main(){
Imagen origen;
Imagen destino(150,200);
// Crear un degradado en la imagen destino
for (int i=0; i < destino.filas()*destino.columnas(); i++)
destino.setPos(i, i%destino.columnas()+20);
// Guardar la imagen destino en el fichero degradado.pgm
if (destino.escribirImagen("degradado.pgm", true)){
// si todo va bien
cout << "degradado.pgm guardado correctamente \n";
cout << "usa: display degradado.pgm para ver el resultado\n";
} else { // si error
cerr << "Error guardando la imagen degradado.pgm\n";
return 1;
}
// Leer la imagen lena.pgm
if (!origen.leerImagen("imagenes/lena.pgm")){
cerr << "error leyendo imagenes/lena.pgm\n";
return 1;
}
// Recortar un trozo de la imagen origen
destino.crear(40,90);
for (int i=0; i < destino.filas(); i++)
for (int j=0; j < destino.columnas(); j++)
destino.set(i, j, origen.get(i+110,j+100));
// Guardar la imagen destino en el fichero trozo.pgm
if (destino.escribirImagen("trozo.pgm", true)){
// si todo va bien
cout << "trozo.pgm guardado correctamente \n";
cout << "usa: display trozo.pgm para ver el resultado\n";
} else { // si error
cerr << "Error guardando la imagen trozo.pgm\n";
return 1;
}
return 0;
}
int main() {
Imagen origen;
Imagen destino(150,200);
// Crear un degradado en la imagen destino
for (int i=0; i < destino.filas()*destino.columnas(); i++)
destino.setPos(i, i%destino.columnas()+20);
// Guardar la imagen destino en el fichero degradado.pgm
if (destino.escribirImagen("degradado.pgm", false)) {
// si todo va bien
cout << "degradado.pgm guardado correctamente \n";
cout << "usa: display degradado.pgm para ver el resultado\n";
} else { // si error
cerr << "Error guardando la imagen degradado.pgm\n";
return 1;
}
// Leer la imagen lena.pgm
if (!origen.leerImagen("imagenes/lena.pgm")) {
cerr << "error leyendo imagenes/lena.pgm\n";
return 1;
}
// Recortar un trozo de la imagen origen
Imagen aux(40,90);
Imagen salida (aux); //Llamamos al operador de asignacion
for (int i=0; i < salida.filas(); i++)
for (int j=0; j < salida.columnas(); j++)
salida.set(i, j, origen.get((i+110)%origen.filas(),(j+100)%origen.columnas()));
//Hemos aplicado un filtro de modulo para que no intente leear fuera del vector de datos
// Guardar la imagen salida en el fichero trozo.pgm
if (salida.escribirImagen("trozo.pgm", false)) {
// si todo va bien
cout << "trozo.pgm guardado correctamente \n";
cout << "usa: display trozo.pgm para ver el resultado\n";
} else { // si error
cerr << "Error guardando la imagen trozo.pgm\n";
return 1;
}
return 0;
}
void Imagen::operator=(Imagen & im2)
{
// este operador no duplica la memoria //
int fil2=im2.fils();
int col2=im2.cols();
if(dim[0]!=fil2 || dim[1]!=col2)
{
// fprintf(stderr,"Diferentes dimensiones al copiar imagenes \n");
dim[0]=fil2;
dim[1]=col2;
delete[] datos;
datos=new double[fil2*col2];
}
int largo=dim[0]*dim[1];
for(int i=0; i<largo; i++)
datos[i]=im2.datos[i];
return;
}
int main(int argc, char *argv[]){
if(argc != 5){
cerr << "Error en el uso: ./suma <img1>.pgm <img2>.pgm <img_resultado>.pgm (t)exto/(b)inario" << endl;
exit(-1);
}
Imagen primera, segunda;
char nombre[100];
bool es_binario;
if(*argv[4]=='t')
es_binario=false;
else if(*argv[4]=='b')
es_binario=true;
else{
cerr << "Formato de salida desconocido..." << endl;
exit(-1);
}
strcpy(nombre, argv[1]);
if(!primera.leerImagen(nombre)){
cerr << "Error leyendo la primera imagen..." << endl;
exit(-1);
}
strcpy(nombre, argv[2]);
if(!segunda.leerImagen(nombre)){
cerr << "Error leyendo la segunda imagen..." << endl;
exit(-1);
}
//Si llegamos hasta aqui, no ha habido errores de lectura
Imagen resultado = primera+segunda;
strcpy(nombre, argv[3]);
if(!resultado.escribirImagen(nombre, es_binario)){
cerr << "Error al escribir en imagen de destino..." << endl;
exit(-1);
}else
cout << "\nConcatenacion realizada. Comprueba el fichero de salida." << endl;
return 0;
}
int main(int argc, char *argv[]) {
Imagen img;
if (argc < 4) {
cout << "Uso: " << "desplazar NumDesplazamientos ImagenEntrada ImagenSalida\n";
return -1;
}
img.crear(0, 0);
if (!img.leer_imagen(argv[2])) { //PAsamos el archivo a leer
cout << "No se puede leer la imagen " << endl;
return -2;
}
desplazar(img, atoi(argv[1]));
if (!img.escribir_imagen(argv[3])) {
cout << "No se puede escribir la imagen " << endl;
return -3;
}
img.destruir();
return 0;
}
int main(){
const int MAX_CSTR_SIZE = 100;
const int MAX_ASCII_ART = 4500;
Imagen imagen;
char ascii_chars[MAX_CSTR_SIZE],
file_path[MAX_CSTR_SIZE],
ascii_art[MAX_ASCII_ART];
cout << "Introduzca la ruta del archivo:";
cin.getline(file_path, MAX_CSTR_SIZE);
cout << "Introduzca los caracteres de conversion:";
cin.getline(ascii_chars, MAX_CSTR_SIZE);
if(!imagen.leerImagen(file_path))
cout << "Error leyendo imagen" << endl;
if(imagen.aArteASCII(ascii_chars, ascii_art, MAX_ASCII_ART))
cout << ascii_art;
else
cout << "Error transformando a ASCIIart" << endl;
}
void Imagen::operator/=(Imagen & im2)
{
// si el divisor es 0, pone 0 en el cociente...
int fil2=im2.fils();
int col2=im2.cols();
if(dim[0]!=fil2 || dim[1]!=col2)
{
fprintf(stderr,"Diferentes dimensiones al multiplicar imagenes \n");
return;
}
int largo=dim[0]*dim[1];
double div;
for(int i=0; i<largo; i++)
{
div=im2.datos[i];
if(fabs(div)>1e-10)
datos[i]/=div;
else
datos[i]=0.0;
}
return;
}