Image processing 用CUDA计算图像梯度时的条纹

我正在写一个图像去噪的代码，在处理过的图像中遇到了一个奇怪的条纹问题。基本上，当我计算图像的X梯度时，会出现水平条纹（或垂直于Y方向）。 整个算法运行正常，看起来我得到了正确的答案（我正在与C语言的程序进行比较），除了那些恼人的条纹

条纹之间的距离随着块大小的不同而变化。每次运行程序时，我的条纹位置也不同！下面是与梯度计算相关的程序部分。我有一种感觉，我在做一件非常愚蠢的事：）谢谢

 #define BLKXSIZE 16
 #define BLKYSIZE 16
 #define idivup(a, b) ( ((a)%(b) != 0) ? (a)/(b)+1 : (a)/(b) )
 void Diff4th_GPU(float* A, float* B, int N, int M, int Z, float sigma, int iter, float tau, int                           type)
 {
    float *Ad; 

dim3 dimBlock(BLKXSIZE,BLKYSIZE);
dim3 dimGrid(idivup(N,BLKXSIZE), idivup(M,BLKYSIZE));

cudaMalloc((void**)&Ad,N*M*sizeof(float));        


cudaMemcpy(Ad,A,N*M*sizeof(float),cudaMemcpyHostToDevice); 

cudaCheckErrors("cc1");
int n = 1;
while (n <= iter) {
    Diff4th2D<<<dimGrid,dimBlock>>>(Ad, N, M, sigma, iter, tau, type);
    n++;
   cudaDeviceSynchronize();
    cudaCheckErrors("kernel");}

cudaMemcpy(B,Ad,N*M*sizeof(float),cudaMemcpyDeviceToHost);
cudaCheckErrors("cc2");
cudaFree(Ad);
 } 

  __global__ void Diff4th2D(float* A, int N, int M, float sigma, int iter, float tau, int type)
 {

float gradX, gradX_sq, gradY, gradY_sq, gradXX, gradYY, gradXY, sq_sum, xy_2, Lam,    V_norm, V_orth, c, c_sq, lam_t;


int i = blockIdx.x*blockDim.x + threadIdx.x;
int j = blockIdx.y*blockDim.y + threadIdx.y;

 int index = j + i*N;

if ((i < N) && (j < M))
  {
    float gradX = 0, gradY = 0, gradXX = 0, gradYY = 0,  gradXY = 0;

    if ((i>1) && (i<N)) {
        if ((j>1) && (j<M)){
    int indexN = (j)+(i-1)*(N);
    if (indexN > ((N*M)-1)) indexN = (N*M)-1;
    if (indexN < 0) indexN = 0;
    int indexS = (j)+(i+1)*(N);
    if (indexS > ((N*M)-1)) indexS = (N*M)-1;
    if (indexS < 0) indexS = 0;
    int indexW = (j-1)+(i)*(N);
    if (indexW > ((N*M)-1)) indexW = (N*M)-1;
    if (indexW < 0) indexW = 0;
    int indexE = (j+1)+(i)*(N);        
    if (indexE > ((N*M)-1)) indexE = (N*M)-1;
    if (indexE < 0) indexE = 0;

   gradX = 0.5*(A[indexN]-A[indexS]);
   A[index] = gradX;
  }
}
}
}

#定义BLKXSIZE 16
#定义BLKYSIZE 16
#定义idivup（a，b）（（a）%（b）！=0）？（a）/（b）+1：（a）/（b））
void diff4thGPU（浮点*A，浮点*B，整数N，整数M，整数Z，浮点西格玛，整数iter，浮点tau，整数类型）
{
浮动*广告；
dim3 dimBlock（BLKXSIZE、BLKYSIZE）；
dim3 dimGrid（idivup（N，BLKXSIZE），idivup（M，BLKYSIZE））；
Cudamaloc（（无效**）和Ad，N*M*sizeof（浮动））；
cudaMemcpy（Ad，A，N*M*sizeof（float），cudaMemcpyHostToDevice）；
cudaCheckErrors（“cc1”）；
int n=1；
而（n1）和（i1）和（j（（n*M）-1））指数n=（n*M）-1；
如果（indexN<0）indexN=0；
int指数=（j）+（i+1）*（N）；
如果（indexS>（（N*M）-1））indexS=（N*M）-1；
如果（indexS<0）indexS=0；
int indexW=（j-1）+（i）*（N）；
如果（indexW>（（N*M）-1））indexW=（N*M）-1；
如果（indexW<0）indexW=0；
指数=（j+1）+（i）*（N）；
如果（indexE>（（N*M）-1））indexE=（N*M）-1；
如果（indexE<0）indexE=0；
gradX=0.5*（A[indexN]-A[indexS]）；
A[指数]=梯度x；
}
}
}
}

内核中有一个竞态条件，因为在使用前可能会覆盖或不会覆盖一个元素

---

使用不同的数组进行输入和输出。

非常感谢，它成功了！看起来CPU编程习惯应该重新考虑：）