CUDA图像处理 | 简单滤波

形态学

• 8邻域腐蚀

  __global__ void Morphology_erode_kernel(
    unsigned char* input,
    unsigned char* ouput,
    int nWidth,
    int nHeight,
    int nWdithStep) {
  
    const int ix = blockIdx.x*blockDim.x + threadIdx.x;
    const int iy = blockIdx.y*blockDim.y + threadIdx.y;
  
    const int ix_1 = max(0, ix - 1);
    const int ix1 = min(nWidth - 1, ix + 1);
    const int iy_1 = max(0, iy - 1);
    const int iy1 = min(nHeight - 1, iy + 1);
  
    if (ix < nWidth&&iy < nHeight) {
        if (input[iy*nWdithStep + ix]) {
            if (input[iy_1*nWdithStep + ix_1] == 0 ||
                input[iy_1*nWdithStep + ix] == 0 ||
                input[iy_1*nWdithStep + ix1] == 0 ||
                input[iy*nWdithStep + ix_1] == 0 ||
                input[iy*nWdithStep + ix1] == 0 ||
                input[iy1*nWdithStep + ix_1] == 0 ||
                input[iy1*nWdithStep + ix] == 0 ||
                input[iy1*nWdithStep + ix1] == 0
                ) {
                ouput[iy*nWdithStep + ix] = 0;
            }
        }
    }
  }

滤波

• 均值滤波

  // 均值滤波
  __global__ void ImgFilter_3x3_m_Kernel(
    unsigned char *input,
    unsigned char *output,
    int nWidth,
    int nHeight,
    int nWdithStep
  ) {
    const int ix = blockIdx.x*blockDim.x + threadIdx.x;
    const int iy = blockIdx.y*blockDim.y + threadIdx.y;
  
    const int ix_1 = max(0, ix - 1);
    const int ix1 = min(nWidth - 1, ix + 1);
    const int iy_1 = max(0, iy - 1);
    const int iy1 = min(nHeight - 1, iy + 1);
  
    if (ix < nWidth&&iy < nHeight) {
        int nTemp;
        nTemp = input[iy_1*nWdithStep + ix_1];
        nTemp += input[iy_1*nWdithStep + ix];
        nTemp += input[iy_1*nWdithStep + ix1];
        nTemp += input[iy*nWdithStep + ix_1];
        nTemp += input[iy*nWdithStep + ix];
        nTemp += input[iy*nWdithStep + ix1];
        nTemp += input[iy1*nWdithStep + ix_1];
        nTemp += input[iy1*nWdithStep + ix];
        nTemp += input[iy1*nWdithStep + ix1];
        nTemp /= 9;
        output[iy_1*nWdithStep + ix] = nTemp;
    }
  }

• 高斯滤波

  // 高斯滤波
  __global__ void ImgFilter_3x3_g_Kernel(
    unsigned char *input,
    unsigned char *output,
    int nWidth,
    int nHeight,
    int nWdithStep
  ) {
    const int ix = blockIdx.x*blockDim.x + threadIdx.x;
    const int iy = blockIdx.y*blockDim.y + threadIdx.y;
  
    const int ix_1 = max(0, ix - 1);
    const int ix1 = min(nWidth - 1, ix + 1);
    const int iy_1 = max(0, iy - 1);
    const int iy1 = min(nHeight - 1, iy + 1);
  
    if (ix < nWidth&&iy < nHeight) {
        int nTemp;
        nTemp = input[iy_1*nWdithStep + ix_1];
        nTemp += input[iy_1*nWdithStep + ix]<<1;
        nTemp += input[iy_1*nWdithStep + ix1];
        nTemp += input[iy*nWdithStep + ix_1]<<1;
        nTemp += input[iy*nWdithStep + ix]<<2;
        nTemp += input[iy*nWdithStep + ix1]<<1;
        nTemp += input[iy1*nWdithStep + ix_1];
        nTemp += input[iy1*nWdithStep + ix]<<1;
        nTemp += input[iy1*nWdithStep + ix1];
        nTemp >>=4;
        output[iy_1*nWdithStep + ix] = nTemp;
    }
  }

• Laplacian算子边缘检测

  // 四邻域二姐边缘算子
  /*
  0  1  0 
  1 -4  1
  0  1  0
  */
  __global__ void ImgFilter_3x3_Kernel(
    unsigned char *input,
    unsigned char *output,
    int nWidth,
    int nHeight,
    int nWdithStep
  ) {
    const int ix = blockIdx.x*blockDim.x + threadIdx.x;
    const int iy = blockIdx.y*blockDim.y + threadIdx.y;
  
    const int ix_1 = max(0, ix - 1);
    const int ix1 = min(nWidth - 1, ix + 1);
    const int iy_1 = max(0, iy - 1);
    const int iy1 = min(nHeight - 1, iy + 1);
  
    if (ix < nWidth&&iy < nHeight) {
        int nTemp;
        nTemp = input[iy_1*nWdithStep + ix];
        nTemp += input[iy*nWdithStep + ix_1];
        nTemp -= input[iy*nWdithStep + ix]<<2;
        nTemp += input[iy*nWdithStep + ix1];
        nTemp += input[iy1*nWdithStep + ix1];
        nTemp =abs(nTemp);
        nTemp =min(255,nTemp);
        output[iy*nWdithStep + ix] = nTemp;
    }
  }