void inciso3() {
unsigned int w = 256;
unsigned int h = 256;
CImg<double> linea_vertical = lineaVertical(w,h,w/2).get_normalize(0,255);
CImg<double> linea_horizontal = lineaHorizontal(w,h,h/2).get_normalize(0,255);
CImg<double> cuadrado = rectCentrado(w,h,w/40,h/4).get_normalize(0,255);
CImg<double> rectangulo = rectCentrado(w,h,w/2,h/10).get_normalize(0,255);
CImg<double> circulo = circuloCentrado(w,0).get_normalize(0,255);
CImgList<double> lista;
lista.assign(linea_vertical,linea_horizontal,cuadrado,rectangulo,circulo);
lista.display();
//CImgList<double> f_linea_vertical = linea_vertical.get_FFT();
//CImgList<double> f_linea_horizontal = linea_horizontal.get_FFT();
//CImgList<double> f_cuadrado = cuadrado.get_FFT();
//CImgList<double> f_rectangulo = rectangulo.get_FFT();
//CImgList<double> f_circulo = circulo.get_FFT();
CImg<double> fm_linea_vertical = magn_tdf(linea_vertical, true);
CImg<double> fm_linea_horizontal = magn_tdf(linea_horizontal, true);
CImg<double> fm_cuadrado = magn_tdf(cuadrado, true);
CImg<double> fm_rectangulo = magn_tdf(rectangulo, true);
CImg<double> fm_circulo = magn_tdf(circulo, true);
CImgList<double> lista_fft;
lista_fft.assign(fm_linea_vertical, fm_linea_horizontal, fm_cuadrado, fm_rectangulo, fm_circulo);
lista_fft.display();
}
int main(int argc, char *argv[]) {
//@ Leer filtro, aplicar filtro, convolve con filtro de distinta medida. Filtra segun un umbral
const char* _input = cimg_option("-i", "../images/hubble.tif", "Input Image File");
const char* _filter = cimg_option("-m", "filtro_ej3.txt", "Input filter File");
const unsigned int _lado = cimg_option("-l", 5, "Input filter File");
const unsigned int _umbral = cimg_option("-u", 150, "Input filter File");
CImg<unsigned char> img(_input), output, output_grises(img.width(), img.height(), 1 , 1 , 0),
img_binaria(img.width(), img.height(), 1 , 1 , 0);
//Creamos el filtro de promediado
utils::genArchivoMascara(_filter, _lado, _lado);
CImg<double> filtro = utils::get_filtro(_filter);
//Convolucionamos
output = img.get_convolve(filtro);
//Binarizamos la imagen a partir del umbral definido
cimg_forXY(output, x , y) {
if (output(x,y) > _umbral ) {
img_binaria(x,y) = 255;
output_grises(x,y) = img(x,y);
}
}
//Dibujamos
CImgList<double> lista;
lista.assign(img, output, img_binaria, output_grises );
lista.display();
}
int main( int argc, char **argv ) {
const char *filename = cimg_option( "-f",
"../../imagenes/estanbul.tif",
"ruta archivo imagen" );
int umbral = cimg_option( "-u", 127, "umbral" );
CImgDisplay disp, disp2, disp3, disp4, disp5, disp6, disp7, disp8;
CImg<double> img ( filename ), gx, gy, gxy, gyx;
img.channel(0);
img.display(disp);
gx = img.get_convolve( masks::sobel_gx() );
gy = img.get_convolve( masks::sobel_gy() );
gxy = img.get_convolve( masks::sobel_gxy() );
gyx = img.get_convolve( masks::sobel_gyx() );
CImgList<double> list ( gx, gy, gxy ,gyx );
list.display(disp3);
disp3.set_title("deteccion de bordes: sobel gx - gy - gxy - gyx");
(gx+gy+gxy+gyx).normalize(0,255).display(disp4);
disp4.set_title("deteccion de bordes: sobel gx + gy + gxy + gyx");
CImgList<double> list2 ( gx.get_normalize(0,255).get_threshold( umbral ),
gy.get_normalize(0,255).get_threshold( umbral ),
gxy.get_normalize(0,255).get_threshold( umbral ),
gyx.get_normalize(0,255).get_threshold( umbral ) );
list2.display(disp7);
disp7.set_title("sobel umbral: gx - gy - gxy - gyx");
CImgList<double> list3 ( masks::sobel_gx().resize(100,100),
masks::sobel_gy().resize(100,100),
masks::sobel_gxy().resize(100,100),
masks::sobel_gyx().resize(100,100) );
list3.display(disp8);
disp8.set_title("masks sobel: gx - gy - gxy - gyx");
while ( (!disp.is_closed() && !disp.is_keyQ()) ) {
disp.wait_all();
}
return 0;
}
int main(int argc, char *argv[]) {
//@ Leer filtro, aplicar filtro, convolve con filtro de distinta medida
const char* _input = cimg_option("-i", "../images/cameraman.tif", "Input Image File");
const char* _filter = cimg_option("-m", "filtro_examen_m1.txt", "Input filter File");
const char* _filter2 = cimg_option("-s", "filtro_examen_m2.txt", "Input filter File");
CImg<double> img(_input), m1, m2;
CImg<double> filtro = get_filtro(_filter);
CImg<double> filtro2 = get_filtro(_filter2);
m1 = img.get_convolve(filtro);
m2 = m1.get_convolve(filtro2);
CImgList<unsigned char> lista;
lista.assign(img, m1, m2);
lista.display();
}
void inciso4() {
unsigned int w = 512;
unsigned int h = 512;
CImg<double> linea = lineaVertical(w,h,w/2).get_normalize(0,255);
CImg<double> rotada = linea.get_rotate(20);
CImg<double> c_linea = linea.get_crop(w/4,h/4,3*w/4, 3*h/4);
CImg<double> c_rotada = rotada.get_crop(w/4+100,h/4,3*w/4+100, 3*h/4);
CImgList<double> lista;
lista.assign(linea,rotada,c_linea,c_rotada);
lista.display();
CImg<double> fm_linea = magn_tdf(c_linea, true);
CImg<double> fm_rotada = magn_tdf(c_rotada, true);
CImgList<double> lista_fft;
lista_fft.assign(fm_linea, fm_rotada);
lista_fft.display();
}
int main(int argc, char *argv[]) {
if ( !argv[1] ){
printf( "%s: Convoluciona la imagen con un kernel de 3x3.\n", argv[0] );
printf( "uso: %s <archivo_imagen>\n", argv[0] );
return 1;
}
CImg<double> kernel ( 3,3,1,1,1);
kernel(0,0)=0; kernel(1,0)=1; kernel(2,0)=2;
kernel(0,1)=1; kernel(1,1)=2; kernel(2,1)=1;
kernel(0,2)=2; kernel(1,2)=1; kernel(2,2)=0;
CImg<double> imagen( argv[1] );
CImgList<double> result ( imagen.get_normalize(0,255),
kernel.get_normalize(0,255),
imagen.get_convolve( kernel ).get_normalize(0,255) );
result.display();
return 0;
}
// Main procedure
//----------------
int main (int argc, char **argv) {
cimg_usage("Compute the skeleton of a shape, using Hamilton-Jacobi equations");
// Read command line arguments
cimg_help("Input/Output options\n"
"--------------------");
const char* file_i = cimg_option("-i",cimg_imagepath "milla.bmp","Input (black&white) image");
const int median = cimg_option("-median",0,"Apply median filter");
const bool invert = cimg_option("-inv",false,"Invert image values");
const char* file_o = cimg_option("-o",(char*)0,"Output skeleton image");
const bool display = cimg_option("-visu",true,"Display results");
cimg_help("Skeleton computation parameters\n"
"-------------------------------");
const float thresh = cimg_option("-t",-0.3f,"Threshold");
const bool curve = cimg_option("-curve",false,"Create medial curve");
cimg_help("Torsello correction parameters\n"
"------------------------------");
const bool correction = cimg_option("-corr",false,"Torsello correction");
const float dlt1 = 2;
const float dlt2 = cimg_option("-dlt",1.0f,"Discrete step");
// Load the image (forcing it to be scalar with 2 values { 0,1 }).
CImg<unsigned int> image0(file_i), image = image0.get_norm().quantize(2).normalize(0.0f,1.0f);
if (median) image.blur_median(median);
if (invert) (image-=1)*=-1;
if (display) (image0.get_normalize(0,255),image.get_normalize(0,255)).display("Input image - Binary image");
// Compute distance map.
CImgList<float> visu;
CImg<float> distance = image.get_distance(0);
if (display) visu.insert(distance);
// Compute the gradient of the distance function, and the flux (divergence) of the gradient field.
const CImgList<float> grad = distance.get_gradient("xyz");
CImg<float> flux = image.get_flux(grad,1,1);
if (display) visu.insert(flux);
// Use the Torsello correction of the flux if necessary.
if (correction) {
CImg<float>
logdensity = image.get_logdensity(distance,grad,flux,dlt1),
nflux = image.get_corrected_flux(logdensity,grad,flux,dlt2);
if (display) visu.insert(logdensity).insert(nflux);
flux = nflux;
}
if (visu) {
cimglist_apply(visu,normalize)(0,255);
visu.display(visu.size()==2?"Distance function - Flux":"Distance function - Flux - Log-density - Corrected flux");
}
// Compute the skeleton
const CImg<unsigned int> skel = image.get_skeleton(flux,distance,curve,thresh);
if (display) {
(image0.resize(-100,-100,1,3)*=0.7f).get_shared_channel(1)|=skel*255.0;
image0.draw_image(0,0,0,0,image*255.0,0.5f).display("Image + Skeleton");
}
// Save output image if necessary.
if (file_o) skel.save(file_o);
return 0;
}
int main(int argc, char *argv[]) {
//@ Compara el resultado de ecualizar una imagen a partir de cada canal RGB y la intensidad de HSI
const char* _input = cimg_option("-i", "../images/futbol.jpg", "Input Image File");
//Declaramos imagenes a trabajar
CImg<double> input(_input), output(input.width(), input.height(), input.depth(), 3 , 0) ;
(input.get_RGBtoHSI().get_channel(0), input.get_RGBtoHSI().get_channel(1)).display();
CImg<double> recorte = input.get_crop(132,105,203,230);
// recorte.display();
// CImg<unsigned char> histograma_r = recorte.get_channel(0).get_histogram(256, 0, 255);
// CImg<unsigned char> histograma_g = recorte.get_channel(1).get_histogram(256, 0, 255);
// CImg<unsigned char> histograma_b = recorte.get_channel(2).get_histogram(256, 0, 255);
// histograma_r.display_graph("",3);
// histograma_g.display_graph("",3);
// histograma_b.display_graph("",3);
CImg<bool> mascara_binaria(input.width(), input.height());
CImg<double> c1 = input.get_channel(0);
CImg<double> c2 = input.get_channel(1);
CImg<double> c3 = input.get_channel(2);
cimg_forXY(input, x , y) {
if (dentro_circulo(c1(x,y), 40, 20) && //rojo
dentro_circulo(c2(x,y), 85, 10) && //verde
dentro_circulo(c3(x,y), 150, 105)) { //azul
mascara_binaria(x,y) = true;
output(x,y,0,0) = input(x,y,0,0);
output(x,y,0,1) = input(x,y,0,1);
output(x,y,0,2) = input(x,y,0,2);
} else {
mascara_binaria(x,y) = false;
}
}
// //Display!
CImgList<double> lista;
lista.assign(input, mascara_binaria.normalize(0,255) , output );
lista.display();
// CImg<double> output_RGB(_input);
// CImg<double> output_HSI(_input);
// CImg<double> filtro = get_filtro(_filtro);
// //Temporales necesarios
// CImg<double> c1, c2, c3;
// //Ecualización de la RGB
// //Obtenemos los canales
// c1 = output_RGB.get_channel(0);
// c2 = output_RGB.get_channel(1);
// c3 = output_RGB.get_channel(2);
// //Los ecualizamos
// c1.convolve(filtro);
// c2.convolve(filtro);
// c3.convolve(filtro);
// //Recomponemos la imágen
// c1.append(c2, 'c');
// c1.append(c3, 'c');
// output_RGB = c1;
// //Ecualizamos la imagen HSI
// output_HSI.RGBtoHSI();
// //Obtenemos los canales
// c1 = output_HSI.get_channel(0);
// c2 = output_HSI.get_channel(1);
// c3 = output_HSI.get_channel(2);
// //Ecualizo el canal de Intensidad solamente
// c3.convolve(filtro);
// //Recomponemos la imágen
// c1.append(c2, 'c');
// c1.append(c3, 'c');
// output_HSI = c1;
// output_HSI.HSItoRGB();
// return 0;
}
//' Display image list using CImg library
//'
//' @param imlist a list of cimg objects
//' @export
// [[Rcpp::export]]
void display_list(List imlist)
{
CImgList<double> L = sharedCImgList(imlist);
L.display();
return;
}
