Bildfaltung und Grenzen

Question

Ich habe versucht, den Faltungsalgorithmus auf einem 1-dimensionalen Array zu implementieren, muss aber als 2D NxM-Matrix dargestellt werden. Nach dem Versuch, ein ähnliches Verfahren wie diese umzusetzen:

int kCenterX = kCol/2; 
int kCenterY = kRow/2; 

for(int i=0; i < mRow; ++i) {    // rows 
    for(int j=0; j < mCol; ++j) {   // columns 

     for(int m=0; m < kRow; ++m) {  // kernel rows 
      int mm = kRow - 1 - m;  // row index of flipped kernel 
      for(int n=0; n < kCol; ++n) { // kernel columns 
       int nn = kCol - 1 - n; // column index of flipped kernel 

       // index of input signal, used for checking boundary 
       int ii = i + (m - kCenterY); 
       int jj = j + (n - kCenterX); 

       // ignore input samples which are out of bound 
       if(ii >= 0 && ii < mRow && jj >= 0 && jj < mCol) 
        o[i][j] += input[ii][jj] * kern[mm][n]; 
      } 
     } 
    } 
} 

Quelle: http://www.songho.ca/dsp/convolution/convolution.html#convolution_2d

Und da die beiden Matrizen gegeben sind:

input = {1,2,3,4,5,6,7,8,9,10,11,12,15,16}; 
// 1 2 3 4 
// 5 6 7 8 
// 9 10 11 12 
// 13 14 15 16 

sharpen_kernel = {0,-1,0,-1,5,-1,0,-1,0}; 
// 0 -1 0 
// -1 5 -1 
// 0 -1 0 

Das Problem ist der Codierer, die es entwickelt festgelegt, dass alle Werte außerhalb der Kanten sind 0. Also, welche Methode könnte ich verwenden, um zu überprüfen, wenn ein Element am Rand eines Arrays ist, und dann diese Werte herauszudrücken, damit sie mit den Kernel-Werten berechnet werden. Im Wesentlichen die Matrix darstellen als:

1 1 2 3 4 4 
1 *1 2 3 4* 4 
5 *5 6 7 8* 8 
9 *9 10 11 12* 12 
13 *13 14 15 16* 16 
13 13 14 15 16 16 

Answer 1

Hier wird der aktualisierte Code ist

int kCenterX = kCol/2; 
int kCenterY = kRow/2; 

for(int i=0; i < mRow; ++i) {    // rows 
    for(int j=0; j < mCol; ++j) {   // columns 

     for(int m=0; m < kRow; ++m) {  // kernel rows 
      int mm = kRow - 1 - m;  // row index of flipped kernel 
      for(int n=0; n < kCol; ++n) { // kernel columns 
       int nn = kCol - 1 - n; // column index of flipped kernel 

       // index of input signal, used for checking boundary 
       int ii = i + (m - kCenterY); 
       int jj = j + (n - kCenterX); 

       if(ii < 0) 
        ii=ii+1; 
       if(jj < 0) 
        jj=jj+1; 
       if(ii >= mRow) 
        ii=ii-1; 
       if(jj >= mCol) 
        jj=jj-1;  
       if(ii >= 0 && ii < mRow && jj >= 0 && jj < mCol) 
        o[i][j] += input[ii][jj] * kern[mm][n]; 

      } 
     } 
    } 
}