static void process(char *ims, char *imt, char* imd){
pnm pims = pnm_load(ims);
pnm pimt = pnm_load(imt);
int colst = pnm_get_width(pimt);
int rowst = pnm_get_height(pimt);
int colss = pnm_get_width(pims);
int rowss = pnm_get_height(pims);
pnm pimd = pnm_new(colst, rowst, PnmRawPpm);
float * LABs = malloc(colss * rowss * 3 * sizeof(float));
float * LABt = malloc(colst * rowst * 3 * sizeof(float));
float * LABd = malloc(colst * rowst * 3 * sizeof(float));
// Conversion des images sources (pims) et target (pimt) en format lab (LABs et LABt)
RGB2LAB(pims, LABs, colss, rowss);
RGB2LAB(pimt, LABt, colst, rowst);
// Colorisation de l'image de destination LABd (en format lab)
colorization(LABs, LABt, LABd, colst, rowst, colss, rowss);
// Conversion de l'image de destination (LABd) en format RGB (pimd)
LAB2RGB(pimd, LABd, colst, rowst);
free(LABs);
free(LABt);
free(LABd);
pnm_save(pimd, PnmRawPpm, imd);
pnm_free(pimt);
pnm_free(pimd);
pnm_free(pims);
}
void
process(char* ims_name,char* imd_name){
pnm ims = pnm_load(ims_name);
int cols = pnm_get_width(ims);
int rows = pnm_get_height(ims);
pnm imd = pnm_new(cols, rows, PnmRawPpm);
unsigned short *ps = pnm_get_image(ims);
unsigned short *pd = pnm_get_image(imd);
int i,j;
unsigned short *image = pnm_get_image(ims);
for(i=0;i<rows;i++){
for(j=0;j<cols;j++){
ps = image + pnm_offset(ims,i,j);
for(int c=0; c<3; c++){
*pd = (*ps + *(ps+1) + *(ps+2)) / 3;
pd++;
}
}
}
pnm_save(imd, PnmRawPpm, imd_name);
pnm_free(imd);
pnm_free(ims);
}
void
process(int num, char* ims_name, char* imd_name){
pnm ims = pnm_load(ims_name);
int height = pnm_get_height(ims);
int width = pnm_get_width(ims);
pnm imd = pnm_new(width, height, PnmRawPpm);
unsigned short r,g,b;
for(int y=0; y<height; y++){
for(int x=0; x<width; x++){
for(int z=0; z<3; z++){
switch (num){
case 1:
r = pnm_get_component(ims, y, x,PnmRed);
pnm_set_component(imd,y,x,PnmRed, r);
pnm_set_component(imd,y,x,PnmGreen, 0);
pnm_set_component(imd,y,x,PnmBlue, 0);
break;
case 2:
g = pnm_get_component(ims, y, x,PnmGreen);
pnm_set_component(imd,y,x,PnmRed, 0);
pnm_set_component(imd,y,x,PnmGreen, g);
pnm_set_component(imd,y,x,PnmBlue, 0);
break;
case 3:
b = pnm_get_component(ims, y, x,PnmBlue);
pnm_set_component(imd,y,x,PnmRed, 0);
pnm_set_component(imd,y,x,PnmGreen, 0);
pnm_set_component(imd,y,x,PnmBlue, b);
break;
}
}
}
}
pnm_save(imd, PnmRawPpm, imd_name);
pnm_free(imd);
pnm_free(ims);
}
void process(int factor, char* filter, char* ims_name, char* imd_name){
/* Selection du filtre */
float (*function_pointer) (float);
if(strcmp(filter,"box") == 0){
printf("box filter\n");
function_pointer = box;
}
else if(strcmp(filter,"tent") == 0){
printf("tent filter\n");
function_pointer = tent;
}
else if(strcmp(filter,"gauss") == 0){
printf("gaussian filter\n");
function_pointer = gaussian;
}
else if(strcmp(filter,"bell") == 0){
printf("bell filter\n");
function_pointer = bell;
}
else if(strcmp(filter,"mitch") == 0){
printf("Mitchell-Netravali filter\n");
function_pointer = mitchell_netravali;
}
else {
printf("unknown filter,\n filters avalaible: box, tent, gauss, bell, mitch");
assert(false);
}
pnm ims = pnm_load(ims_name);
int height = pnm_get_height(ims);
int width = pnm_get_width(ims);
int height2 = height * factor;
int width2 = width * factor;
float wf = factor / 2;
pnm imd = pnm_new(width2, height2, PnmRawPpm);
/* image contiendra les valeur des pixels de l'image source, image2 contiendra l'image en cours de modification et image3 contiendra les images pivotées dont l'image finale*/
unsigned short * image = (unsigned short *) malloc(width * height * sizeof(unsigned short));
unsigned short * image2 = (unsigned short *) malloc(width2 * height2 * sizeof(unsigned short));
unsigned short * image3 = (unsigned short *) malloc(width2 * height2 * sizeof(unsigned short));
image = pnm_get_channel(ims, image, PnmRed);
float left, right, s, l;
int i_origin;
/* On applique le filtre sur les lignes */
for(int i=0; i < height2; i++){
i_origin = i / factor;
for(int l2=0; l2 < width2; l2++){
l = l2 / factor;
left = (l - wf) >= 0 ? (l - wf) : 0;
right = (l + wf) <= width ? (l + wf) : width;
s = 0;
for(int k=left; k <= right; k++)
s += image[k + i_origin * width] * function_pointer(k-l);
if(s > 255)
s = 255;
else if(s < 0)
s = 0;
image2[i_origin * width2 + l2] = s;
}
}
/* retourne l'image pour que l'on puisse travailler sur les colonnes */
flip(width2, height2, image3, image2);
/* On applique le filtre sur les colonnes */
for(int i=0; i < height2; i++){
for(int l2=0; l2 < width2; l2++){
l = l2 / factor;
left = (l - wf) >= 0 ? (l - wf) : 0;
right = (l + wf) <= width ? (l + wf) : width;
s = 0;
for(int k=left; k <= right; k++)
s += image3[k + i * width2] * function_pointer(k-l);
if(s > 255)
s = 255;
else if(s < 0)
s = 0;
image2[i * width2 + l2] = s;
}
}
flip(width2, height2, image3, image2);
pnm_set_channel(imd, image3, PnmRed);
pnm_set_channel(imd, image3, PnmGreen);
pnm_set_channel(imd, image3, PnmBlue);
pnm_save(imd, PnmRawPpm, imd_name);
free(image);
free(image2);
free(image3);
pnm_free(imd);
pnm_free(ims);
}
void
process(int factor, char* filter_name,char* ims_name, char* imd_name) {
pnm ims = pnm_load(ims_name);
int cols = pnm_get_width(ims);
int rows = pnm_get_height(ims);
int new_cols = factor*cols;
int new_rows = factor*rows;
pnm imw = pnm_new(new_cols, rows, PnmRawPpm);
pnm imd = pnm_new(new_cols, new_rows, PnmRawPpm);
// ===== Columns interpolation =====
for(int i=0; i<rows; i++) {
for(int j=0; j<new_cols; j++) {
float new_j = (float)j / factor;
float WF = 0;
if (strcmp(filter_name, "box")== 0)
WF = 0.5;
else if (strcmp(filter_name, "tent")== 0)
WF = 1.0;
else if (strcmp(filter_name, "bell")== 0)
WF = 1.5;
else if (strcmp(filter_name, "mitch")== 0)
WF = 2.0;
float left = new_j - WF;
float right = new_j + WF;
int l_int = floor(left);
int r_int = floor(right);
float S = 0.0;
for (int k=l_int; k <= r_int; k++) {
float h = 0.0;
if (strcmp(filter_name, "box")== 0)
h = box((float)k-new_j);
else if (strcmp(filter_name, "tent")== 0)
h = tent((float)k-new_j);
else if (strcmp(filter_name, "bell")== 0)
h = bell((float)k-new_j);
else if (strcmp(filter_name, "mitch")== 0)
h = mitch((float)k-new_j);
if (k<0) {
S += pnm_get_component(ims, i, 0, 0)*h;
}
else if (k>=cols) {
S += pnm_get_component(ims, i, cols-1, 0)*h;
}
else {
S += pnm_get_component(ims, i, k, 0)*h;
}
}
for (int c=0; c<3; c++) {
pnm_set_component(imw, i, j, c, (unsigned short) S);
}
}
}
// ===== Rows interpolation =====
for(int i=0; i<new_rows; i++) {
for(int j=0; j<new_cols; j++) {
float new_i = (float) i / factor;
float WF = 0;
if (strcmp(filter_name, "box")== 0)
WF = 0.5;
else if (strcmp(filter_name, "tent")== 0)
WF = 1.0;
else if (strcmp(filter_name, "bell")== 0)
WF = 1.5;
else if (strcmp(filter_name, "mitch")== 0)
WF = 2.0;
float above = new_i - WF;
float below = new_i + WF;
int a_int = floor(above);
int b_int = floor(below);
float S = 0.0;
for (int k=a_int; k <= b_int; k++) {
float h = 0.0;
if (strcmp(filter_name, "box")== 0)
h = box((float)k-new_i);
else if (strcmp(filter_name, "tent")== 0)
h = tent((float)k-new_i);
else if (strcmp(filter_name, "bell")== 0)
h = bell((float)k-new_i);
else if (strcmp(filter_name, "mitch")== 0)
h = mitch((float)k-new_i);
if (k<0) {
S += pnm_get_component(imw, 0, j, 0)*h;
}
else if (k>=rows) {
S += pnm_get_component(imw, rows-1, j, 0)*h;
}
else {
S += pnm_get_component(imw, k, j, 0)*h;
}
}
for (int c=0; c<3; c++) {
pnm_set_component(imd, i, j, c, (unsigned short) S);
}
}
}
pnm_save(imd, PnmRawPpm, imd_name);
pnm_free(ims);
pnm_free(imw);
pnm_free(imd);
}
void
process(int min, int max, char* ims_name, char* imd_name){
pnm ims = pnm_load(ims_name);
int height = pnm_get_height(ims);
int width = pnm_get_width(ims);
pnm imd = pnm_new(width, height, PnmRawPpm);
unsigned short r,g,b,min_r,min_g,min_b,max_r,max_g,max_b;
min_r = 255;
min_g = 255;
min_b = 255;
max_r = 0;
max_g = 0;
max_b = 0;
for(int y=0; y<height; y++){
for(int x=0; x<width; x++){
for(int z=0; z<3; z++){
r = pnm_get_component(ims, y, x, PnmRed);
g = pnm_get_component(ims, y, x, PnmGreen);
b = pnm_get_component(ims, y, x, PnmBlue);
if(r < min_r){
min_r = r;
}
if(g < min_g){
min_g = g;
}
if(b < min_b){
min_b = b;
}
if(r > max_r){
max_r = r;
}
if(g > max_g){
max_g = g;
}
if(b > max_b){
max_b = b;
}
}
}
}
unsigned short normalize_r, normalize_g, normalize_b;
for(int y=0; y<height; y++){
for(int x=0; x<width; x++){
for(int z=0; z<3; z++){
normalize_r = (max - min) / (max_r - min_r) * pnm_get_component(ims, y, x, PnmRed) + (min * max_r - max * min_r) / (max_r - min_r);
normalize_g = (max - min) / (max_g - min_g) * pnm_get_component(ims, y, x, PnmGreen) + (min * max_g - max * min_g) / (max_g - min_g);
normalize_b = (max - min) / (max_b - min_b) * pnm_get_component(ims, y, x, PnmBlue) + (min * max_b - max * min_b) / (max_b - min_b);
pnm_set_component(imd, y, x, PnmRed, normalize_r);
pnm_set_component(imd, y, x, PnmGreen, normalize_g);
pnm_set_component(imd, y, x,PnmBlue, normalize_b);
}
}
}
printf("****** valeurs min r g b ****** \n");
printf("%u \n", min_r);
printf("%u \n", min_g);
printf("%u \n", min_b);
printf("****** valeurs max r g b ****** \n");
printf("%u \n", max_r);
printf("%u \n", max_g);
printf("%u \n", max_b);
printf("****** valeurs normalize r g b ****** \n");
printf("%u \n", normalize_r);
printf("%u \n", normalize_g);
printf("%u \n", normalize_b);
pnm_save(imd, PnmRawPpm, imd_name);
pnm_free(imd);
pnm_free(ims);
}
void process(char* ims_name, char* imd_name, char* filter, int d0, int n, int w, int u0, int v0) {
/* Selection du filtre */
/*float (*function_pointer) (double, double, double, double, int, int, int);
if(strcmp(filter,"lp") == 0){
printf("low pass filter\n");
function_pointer = lp;
}
else if(strcmp(filter,"hp") == 0){
printf("high pass filter\n");
function_pointer = hp;
}
else if(strcmp(filter,"br") == 0){
printf("band reject filter\n");
function_pointer = br;
}
else if(strcmp(filter,"bp") == 0){
printf("band pass filter\n");
function_pointer = br;
}
else if(strcmp(filter,"no") == 0){
printf("rejet d'encoche \n");
function_pointer = no;
}
else {
printf("unknown filter,\n filters avalaible: lp, hp, br, bp, no");
assert(false);
}*/
pnm ims = pnm_load(ims_name);
int width = pnm_get_width(ims);
int height = pnm_get_height(ims);
pnm imd = pnm_new(width, height, PnmRawPpm);
unsigned short * image = (unsigned short *) malloc(height * width * sizeof(unsigned short));
fftw_complex * freq_repr = (fftw_complex *) fftw_malloc(height* width * sizeof(fftw_complex));
image = pnm_get_channel(ims, image, PnmRed);
freq_repr = fft_forward(height, width, image);
float * as = (float *) malloc(sizeof(float) * height * width);
float * ps = (float *) malloc(sizeof(float) * height * width);
fft_fr_to_spectra(width, height, freq_repr, as, ps);
pnm imd2 = pnm_new(width, height, PnmRawPpm);
for(int y = 0; y < height; y++)
for(int x = 0; x < width; x++)
for(int z = 0; z < 3; z++)
pnm_set_component(imd2,y,x,z,as[x+y*height]);
pnm_save(imd2, PnmRawPpm, "toto.ppm");
//float d_u_v;
for(int j=0; j<height; j++){
for(int i=0; i<width; i++){
//d_u_v = sqrt((float)(j-height/2)*(j-height/2)+(float)(i-width/2)*(i-width/2));
//as[i+j*width] = function_pointer(i, j, u0, v0, n, w, d0) * as[i+j*width];
as[i+j*width] = low_pass(d0, n, d((float) i-width/2,(float) j-height/2)) * as[i+j*width];
//printf("%f \n", hp(i, j, u0, v0, n, w, d0));
//printf("%d \n", function_pointer(i, j, u0, v0, n, w, d0));
}
}
pnm imd3 = pnm_new(width, height, PnmRawPpm);
for(int y = 0; y < height; y++)
for(int x = 0; x < width; x++)
for(int z = 0; z < 3; z++)
pnm_set_component(imd3,y,x,z,as[x+y*height]);
pnm_save(imd3, PnmRawPpm, "toto2.ppm");
fft_spectra_to_fr(height,width,as,ps, freq_repr);
image = fft_backward(height, width, freq_repr);
for(int y = 0; y < height; y++)
for(int x = 0; x < width; x++)
for(int z = 0; z < 3; z++)
pnm_set_component(imd,y,x,z,image[x+y*height]);
pnm_save(imd, PnmRawPpm, imd_name);
free(image);
}