convol2.c

LastWave

    image_output = (LWFLOAT *)output->pixels;

    for(i= 0, I= 0, Iout= 0; i < nrow; i++, I+= ncol, Iout+= ncol_out) {
	W2_ref(border,ncol,image_input+I,W2_convbf);
	for(j= 0; j < ncol_out; j++) {
	    sum= filter[0] * W2_convbf[j];
	    for(k= 1, left= j-l1, right= j+r1;
		k < filtsize ;
		k++, right+= scale, left-= scale) {
		sum+= filter[k] * (filtsym*W2_convbf[W2_mod(left,ncol2)]
                                   + W2_convbf[W2_mod(right,ncol2)]);
	    }
	    image_output[Iout+j]= sum/sqrt(W2_renorm_L2[octave]);
	}
    }
}



/*---------------------------------------------------------------------*/
static void W2_conv(IMAGE input,IMAGE output,FILTER2 filt,int  scale)
{
  int ncol = input->ncol,
      nrow = input->nrow;
  int border= input->border_hor;
  LWFLOAT *image_input;
  LWFLOAT *image_output;
  int filtsize = filt->size;
  int filtshift = filt->shift;
  LWFLOAT filtsym = filt->symmetry;
  LWFLOAT *filter = filt->values;
  int i, I, Iout, j, k, left, right, l1, r1;
  LWFLOAT sum;
  int ncol2= 2*(ncol-ncol%2);
  int ncol_out= ncol;
  int border_output= border;

  if(scale == 1) {
  if (W2_mot_proc)  /* special border case for motion, 10/20/92 */
      ncol_out+= (ncol_out%2 ? -1 : 1);
    switch(filtshift) {
     case 1:
      l1= 1;
      r1= 0;
      if(filtsym < 0.0)
        border_output= W2_ASYODD;
      else
        border_output= W2_SYMODD;
      break;
     case -1:
      l1= 0;
      r1= 1;
      if(filtsym < 0.0) {
/* need REWRITE Zhong */
        border_output= border + (border>1 ? -1-2*(border%2) : 3-2*(border%2));
      } else {
        border_output= W2_SYMEVN;
      }
      break;
     case 0:
      l1= r1= 1;
      border_output= border;
      break;
    }
  } else {
    if(filtshift) {
      l1= r1= scale/2;
    } else {
      l1= r1= scale;
    }
    if(filtsym < 0.0) {
      border_output= border + (border>1 ? -2 : 2);
    } else {
      border_output= border;
    }
  }

  SizeImage(output,nrow, ncol_out);
  output->border_hor= border_output;
  output->border_ver= input->border_ver;
  image_input = (LWFLOAT *)input->pixels;
  image_output = (LWFLOAT *)output->pixels;

    for(i= 0, I= 0, Iout= 0; i < nrow; i++, I+= ncol, Iout+= ncol_out) {
      W2_ref(border,ncol,image_input+I,W2_convbf);
      for(j= 0; j < ncol_out; j++) {
        sum= filter[0] * W2_convbf[j];
        for(k= 1, left= j-l1, right= j+r1;
            k < filtsize ;
            k++, right+= scale, left-= scale) {
          sum+= filter[k] * (filtsym*W2_convbf[W2_mod(left,ncol2)]
                                   + W2_convbf[W2_mod(right,ncol2)]);
        }
        image_output[Iout+j]= sum;
      }
    }
}
/*---------------------------------------------------------------------*/
void W2_conv_hv(IMAGE input,IMAGE output,FILTER2 h_filt,int h_scale,FILTER2 v_filt,int v_scale,int norm_L2)
{   IMAGE wrk_image;
wrk_image = NewImage();
    if(norm_L2)
	W2_conv_norm(input,wrk_image,h_filt,h_scale);
    else
	W2_conv(input,wrk_image,h_filt,h_scale);

    TranspImage(wrk_image, output);

    if(norm_L2)
	W2_conv_norm(output,wrk_image,v_filt,v_scale);
    else
	W2_conv(output,wrk_image,v_filt,v_scale);

    TranspImage(wrk_image, output);
    DeleteImage(wrk_image);
}





/*---------------------------------------------------------------------*/

void W2_conv_hv_H1(IMAGE input,IMAGE output,FILTER2 h_filt,int h_scale,FILTER2 v_filt,int v_scale)
{ IMAGE wrk_image;
  wrk_image = NewImage();
  W2_conv(input,wrk_image,h_filt,h_scale);
  TranspImage(wrk_image, output);
  W2_conv(output,wrk_image,v_filt,v_scale);
  TranspImage(wrk_image, output);
  DeleteImage(wrk_image);
}

/*---------------------------------------------------------------------*/
void W2_conv_hv_H2(IMAGE input,IMAGE output,FILTER2 h_filt,int h_scale,FILTER2 v_filt,int v_scale)
{ IMAGE wrk_image;
  
  wrk_image = NewImage();
  W2_conv(input,wrk_image,h_filt,h_scale);
  TranspImage(wrk_image, output);
  W2_conv(output,wrk_image,v_filt,v_scale);
  TranspImage(wrk_image, output);
  DeleteImage(wrk_image);
}

/*---------------------------------------------------------------------*/

static void W2_conv_normd(IMAGE input,IMAGE output, FILTER2 filt,int  scale)
{
    int ncol = input->ncol, 
	nrow = input->nrow;
    int border= input->border_hor;
    LWFLOAT *image_input;
    LWFLOAT *image_output;
    int filtsize = filt->size;
    int filtshift = filt->shift;
    LWFLOAT filtsym = filt->symmetry;
    LWFLOAT *filter = filt->values;
    int i, I, Iout, j, k, left, right, l1, r1;
    LWFLOAT sum;
    int ncol2= 2*(ncol-ncol%2);
    int ncol_out= ncol;
    int border_output= border;
    int octave;

    octave = (int) W2_my_log2((double)scale);

    if(scale == 1) {
	if (!W2_mot_proc) /* special border case for motion, 10/20/92 */
	    ncol_out+= (ncol_out%2 ? -1 : 1);
	switch(filtshift) {
	case 1:
	    l1= 1;
	    r1= 0;
	    if(filtsym < 0.0)
		border_output= W2_ASYODD;
	    else
		border_output= W2_SYMODD;
	    break;
	case -1:
	    l1= 0;
	    r1= 1;
	    if(filtsym < 0.0) {
/* need REWRITE Zhong */
		border_output= border + (border>1 ? -1-2*(border%2) : 3-2*(border%2));
	    } else {
		border_output= W2_SYMEVN;
	    }
	    break;
	case 0:
	    l1= r1= 1;
	    border_output= border;
	    break;
	}
    } else {
	if(filtshift) {
	    l1= r1= scale/2;
	} else {
	    l1= r1= scale;
	}
	if(filtsym < 0.0) {
	    border_output= border + (border>1 ? -2 : 2);
	} else {
	    border_output= border;
	}
    }

    SizeImage(output,nrow, ncol_out);
    output->border_hor= border_output;
    output->border_ver= input->border_ver;
    image_input = (LWFLOAT *)input->pixels;
    image_output = (LWFLOAT *)output->pixels;

    for(i= 0, I= 0, Iout= 0; i < nrow; i++, I+= ncol, Iout+= ncol_out) {
	W2_ref(border,ncol,image_input+I,W2_convbf);
	for(j= 0; j < ncol_out; j++) {
	    sum= filter[0] * W2_convbf[j];
	    for(k= 1, left= j-l1, right= j+r1;
		k < filtsize ;
		k++, right+= scale, left-= scale) {
		sum+= filter[k] * (filtsym*W2_convbf[W2_mod(left,ncol2)]
                                   + W2_convbf[W2_mod(right,ncol2)]);
	    }
	    image_output[Iout+j]= sum*sqrt(W2_renorm_L2[octave]);
	}
    }
}
/*---------------------------------------------------------------------*/

void W2_conv_hv_recons(IMAGE input,IMAGE output,FILTER2 h_filt,int h_scale,FILTER2 v_filt,int v_scale,int norm_L2)
{   IMAGE wrk_image;
    wrk_image = NewImage();
    if(norm_L2)
	W2_conv_normd(input,wrk_image,h_filt,h_scale);
    else
	W2_conv(input,wrk_image,h_filt,h_scale);

    TranspImage(wrk_image, output);

    if(norm_L2)
	W2_conv_normd(output,wrk_image,v_filt,v_scale);
    else
	W2_conv(output,wrk_image,v_filt,v_scale);

    TranspImage(wrk_image, output);
    DeleteImage(wrk_image);
}

/*---------------------------------------------------------------------*/
void W2_convper_normd(IMAGE input,IMAGE output, FILTER2 filt,int  scale)
{
    int ncol = input->ncol, 
	nrow = input->nrow;
    LWFLOAT *image_input;
    LWFLOAT *image_output;
    int filtsize = filt->size;
    int filtshift = filt->shift;
    LWFLOAT filtsym = filt->symmetry;
    LWFLOAT *filter = filt->values;
    int i, I, ind, j, k, left, right, l1, r1;
    LWFLOAT sum,v=sqrt(2);
    int ncol2= 2*(ncol-ncol%2);
    int octave;

    octave = (int)W2_my_log2((double)scale);


    if(scale == 1) {
	switch(filtshift) {
	case 1:
	    l1= 1;
	    r1= 0;
	    break;
	case -1:
	    l1= 0;
	    r1= 1;
	    break;
	case 0:
	    l1= r1= 1;
	    break;
	}
    } else
	if(filtshift) {
	    l1= r1= scale/2;
	} else {
	    l1= r1= scale;
	}


    SizeImage(output,nrow, ncol);
    image_input = (LWFLOAT *)input->pixels;
    image_output = (LWFLOAT *)output->pixels;


    for(i= 0, I= 0; i < nrow; i++, I+= ncol) {
	for(j= 0; j < ncol; j++) {
	    ind=I+j;
	    sum= filter[0] * image_input[ind];
	    for(k= 1, left= j-l1, right= j+r1;
		k < filtsize ;
		k++, right+= scale, left-= scale) {
		sum+= filter[k] * (filtsym*image_input[I+W2_mod(left,ncol)]
                                   + image_input[I+W2_mod(right,ncol)]);
	    }
	    image_output[ind]= sum*sqrt(W2_renorm_L2[octave]);
	}
    }
}
/*---------------------------------------------------------------------*/

void W2_conv_hv_per_recons(IMAGE input,IMAGE output,FILTER2 h_filt,int h_scale,FILTER2 v_filt,int v_scale,int norm_L2)
{   IMAGE wrk_image;
    wrk_image = NewImage();
    if(norm_L2)
	W2_convper_normd(input,wrk_image,h_filt,h_scale);
    else
	W2_convper(input,wrk_image,h_filt,h_scale);

    TranspImage(wrk_image, output);

    if(norm_L2)
	W2_convper_normd(output,wrk_image,v_filt,v_scale);
    else
	W2_convper(output,wrk_image,v_filt,v_scale);

    TranspImage(wrk_image, output);
     DeleteImage(wrk_image);
}
/*---------------------------------------------------------------------*/

void W2_conv_hv_per_H2(IMAGE input,IMAGE output,FILTER2 h_filt,int h_scale,FILTER2 v_filt,int v_scale)
{ IMAGE wrk_image;
  
  wrk_image = NewImage();
 
  W2_convper(input,wrk_image,h_filt,h_scale);
  
  TranspImage(wrk_image, output);

  W2_convper(output,wrk_image,v_filt,v_scale);
 
  TranspImage(wrk_image, output);

   DeleteImage(wrk_image);

}


/*---------------------------------------------------------------------*/