---

ImageGrey-conv.cpp

Go to the documentation of this file.

/**************************************************************************
 *
 * Source code for Real Time Image Library (libRTImage)
 *
 * Leeds Vision Group give permission for this code to be copied, modified 
 * and distributed within the University of Leeds subject to the following 
 * conditions:-
 *
 * - The code is not to be used for commercial gain.
 * - The code and use thereof will be attributed to the author where
 *   appropriate (inluding demonstrations which rely on it's use).
 * - All modified, distributions of the source files will retain this header.
 *
 ****************************************************************************/

#include <stdio.h>
#include <fstream>
#include <ImageGrey.h>
#include <iostream>

using namespace std;

float ImageGrey::convolve(unsigned int x,
                          unsigned int y,
                          CMatrix      *kernel)
{
    int x_off ;
    int y_off ;
    int x_cnt ;
    int y_cnt ;
    int x_min ;
    int x_max ;
    int y_min ;
    int y_max ;
    float        *k_ptr ; 
    int          *d_ptr ; 
    float        ret_val = 0 ;

    x_off = kernel->get_no_columns() / 2 ;
    y_off = kernel->get_no_columns() / 2 ;

    x_min = x-x_off ;
    x_max = x+x_off ;
    y_min = y-y_off ;
    y_max = y+y_off ;

    k_ptr = kernel->data ;

    if(x_min >= 0 &&
       x_max < width &&
       y_min >= 0 &&
       y_max < height){
    // Limis within image, no checks

        for(y_cnt=y_min ; y_cnt<=y_max ; y_cnt++){ 
            d_ptr = brightness + (y_cnt*width) + x_min ;
            for(x_cnt=x_min ; x_cnt<=x_max ; x_cnt++){ 
                ret_val += *(k_ptr++) * *(d_ptr++) ;
            }
        }
  
    }
    else{
    // Kernel partially outside image .. must check

        for(y_cnt=y_min ; y_cnt<=y_max ; y_cnt++){
            d_ptr = brightness + (y_cnt*width) + x_min ;
            for(x_cnt=x_min ; x_cnt<=x_max ; x_cnt++){
                if(x_cnt >= 0 &&
                   x_cnt < width &&
                   y_cnt >= 0 &&
                   y_cnt < height){
                // Point on image
                    ret_val += *(k_ptr++) * *(d_ptr++) ;
                }
                else{
                    k_ptr++ ;
                    d_ptr++ ;
                }
            }
        }

    } 

    return ret_val ;
}

void ImageGrey::plot_conv_kernel(unsigned int x,
                                 unsigned int y,
                                 CMatrix      *kernel,
                                 float        scale_fact,
                                 float        offset)
{
    unsigned int x_off ;
    unsigned int y_off ;
    unsigned int x_cnt ;
    unsigned int y_cnt ;
    unsigned int x_min ;
    unsigned int x_max ;
    unsigned int y_min ;
    unsigned int y_max ;
    float        *k_ptr ;
    int          *d_ptr ;

    x_off = kernel->get_no_columns() / 2 ;
    y_off = kernel->get_no_columns() / 2 ;

    x_min = x-x_off ;
    x_max = x+x_off ;
    y_min = y-y_off ;
    y_max = y+y_off ;

    k_ptr = kernel->data ;

    for(y_cnt=y_min ; y_cnt<=y_max ; y_cnt++){
        d_ptr = brightness + (y_cnt*width) + x_min ;
        for(x_cnt=x_min ; x_cnt<=x_max ; x_cnt++){
           *(d_ptr++) = (int)((float)(*(k_ptr++) + offset) * scale_fact + 0.5) ;
        }
    }

}

float ImageGrey::wavelet_convolve(unsigned int x,
                                  unsigned int y,
                                  Wavelet *wavelet,
                                  float        *real,
                                  float        *imag)
{

    register float    r ;
    register float    i ;


    r = convolve(x, y, wavelet->real_kernel) ;
    i = convolve(x, y, wavelet->imag_kernel) ;

    if(real != NULL) *real = r ;
    if(imag != NULL) *imag = i ;

    i *= i ;
    r *= r ;

    return (r + i) ;
}

void ImageGrey::blur(unsigned int size, ImageGrey &result)
{
    unsigned int x_cnt ;
    unsigned int y_cnt ;
    int          sz_2 ;
    unsigned int hb ;
    unsigned int wb ;
    unsigned int sz_sqd ;
    int          x_cnt2 ;
    int          y_cnt2 ;
    int          *r_ptr ;
    int          *d_ptr ;
    int          *d2_ptr ;

    sz_2 = size / 2 ;
    wb = width - sz_2 - 1 ;
    hb = height - sz_2 - 1 ;
    sz_sqd = size * size ;

    d_ptr = brightness ;
    r_ptr = result.brightness ;

    for(y_cnt=0 ; y_cnt<height ; y_cnt++){
        for(x_cnt=0 ; x_cnt<width ; x_cnt++, d_ptr++, r_ptr++){
            if(x_cnt < sz_2 || x_cnt > wb  ||
               y_cnt < sz_2 || y_cnt > hb ){
            // Too near edge
                *r_ptr = *d_ptr ;
            }
            else{
                *r_ptr = 0 ;
                for(y_cnt2=-sz_2 ; y_cnt2<=sz_2 ; y_cnt2++){
                    d2_ptr = d_ptr + y_cnt2*width - sz_2 ;
                    for(x_cnt2=-sz_2 ; x_cnt2<=sz_2 ; x_cnt2++, d2_ptr++){
                        *r_ptr += *d2_ptr ; 
                    }
                }
                *r_ptr /= sz_sqd ;
            }
        }
    }
}

---