stim/cuda/ivote/local_max.cuh

#ifndef STIM_CUDA_LOCAL_MAX_H
#define STIM_CUDA_LOCAL_MAX_H
# include <iostream>
# include <cuda.h>
#include <stim/cuda/cudatools.h>
namespace stim{
	namespace cuda{
		// this kernel calculates the local maximum for finding the cell centers
		template<typename T>
		__global__ void cuda_local_max(T* gpuCenters, T* gpuVote, T final_t, int conn, int x, int y){
			// calculate the 2D coordinates for this current thread.
			int xi = blockIdx.x * blockDim.x + threadIdx.x;
			int yi = blockIdx.y * blockDim.y + threadIdx.y;
			
			if(xi >= x || yi >= y)
				return;
						
			// convert 2D coordinates to 1D
			int i = yi * x + xi;			
			
			gpuCenters[i] = 0;		//initialize the value at this location to zero
			
			T val = gpuVote[i];
			
			//compare to the threshold
			if(val < final_t) return;
			
			//define an array to store indices with same vote value
			/*int * IdxEq;
			IdxEq = new int  [2*conn];
			int n = 0;*/
			
			for(int xl = xi - conn; xl < xi + conn; xl++){
				for(int yl = yi - conn; yl < yi + conn; yl++){
					if(xl >= 0 && xl < x && yl >= 0 && yl < y){
						int il = yl * x + xl;
						if(gpuVote[il] > val){							
							return;
							}
						if (gpuVote[il] == val){
							/*IdxEq[n] = il;
							n = n+1;*/
							 if( il > i){
								 return;
							}
						}
					}							
				}
			}
			/*if (n!=0){
				if(IdxEq[n/2] !=i){
					return;
				}
			}	*/	
			gpuCenters[i] = 1;
		}
		
		template<typename T>
		void gpu_local_max(T* gpuCenters, T* gpuVote, T final_t, unsigned int conn, unsigned int x, unsigned int y){
			unsigned int max_threads = stim::maxThreadsPerBlock();
			/*dim3 threads(max_threads, 1);
			dim3 blocks(x/threads.x + (x %threads.x == 0 ? 0:1) , y);*/
			dim3 threads( sqrt(max_threads), sqrt(max_threads) );
			dim3 blocks(x/threads.x + 1, y/threads.y + 1);
			
			//call the kernel to find the local maximum.
			cuda_local_max <<< blocks, threads >>>(gpuCenters, gpuVote, final_t, conn, x, y);
		}
		template<typename T>
		void cpu_local_max(T* cpuCenters, T* cpuVote, T final_t, unsigned int conn, unsigned int x, unsigned int y){
		
			//calculate the number of bytes in the array
			unsigned int bytes = x * y * sizeof(T);
			// allocate space on the GPU for the detected cell centes
			T* gpuCenters;
			cudaMalloc(&gpuCenters, bytes);		
			//allocate space on the GPU for the input Vote Image
			T* gpuVote;
			cudaMalloc(&gpuVote, bytes);		
			//copy the Vote image data to the GPU
			HANDLE_ERROR(cudaMemcpy(gpuVote, cpuVote, bytes, cudaMemcpyHostToDevice));
						
			//call the GPU version of the local max function
			gpu_local_max<T>(gpuCenters, gpuVote, final_t, conn, x, y);
							
			//copy the cell centers data to the CPU
			cudaMemcpy(cpuCenters, gpuCenters, bytes, cudaMemcpyDeviceToHost) ;
						
			//free allocated memory
			cudaFree(gpuCenters);
			cudaFree(gpuVote);
		}
		
	}
}
#endif