codebase / stimlib

  #ifndef STIM_CUDA_UPDATE_DIR_THRESHOLD_GLOBALD_H
  #define STIM_CUDA_UPDATE_DIR_THRESHOLD_GLOBAL_H

  
  # include <iostream>
  # include <cuda.h>
  #include <stim/cuda/cudatools.h>
  #include <stim/cuda/sharedmem.cuh>

  #include "cpyToshare.cuh"   

  
  namespace stim{
  	namespace cuda{
  	
  		// this kernel calculates the voting direction for the next iteration based on the angle between the location of this voter and the maximum vote value in its voting area.
  		template<typename T>

  		__global__ void cuda_update_dir(T* gpuDir, T* gpuVote, T* gpuTh, T* gpuTable, T phi, int rmax, int th_size, int x,  int y){

  			
  			// calculate the coordinate for this current thread.

  			int xi = blockIdx.x * blockDim.x + threadIdx.x;

  			// calculate the voting direction based on the grtadient direction
  			float theta = gpuTh[3*xi];

  			//calculate the position and x, y coordinations of this voter in the original image
  			unsigned int i_v = gpuTh[3*xi+2];
  			unsigned int y_v = i_v/x;
  			unsigned int x_v = i_v - (y_v*x);

  			//initialize the vote direction to zero
  			gpuDir[xi] = 0;
  
  			// define a local variable to maximum value of the vote image in the voting area for this voter
  			float max = 0;
  
  			// define two local variables for the x and y coordinations where the maximum happened
  			int id_x = 0;
  			int id_y = 0;
  
  			// compute the size of window which will be checked for finding the voting area for this voter
  			int x_table = 2*rmax +1;

  			int rmax_sq = rmax * rmax;
  			int tx_rmax = threadIdx.x + rmax;

  			if(xi < th_size){
  				
  				for(int yr = -rmax; yr <= rmax; yr++){
  					
  					for(int xr = -rmax; xr <= rmax; xr++){
  
  						unsigned int ind_t = (rmax - yr) * x_table + rmax - xr;
  
  						// find the angle between the voter and the current pixel in x and y directions
  						float atan_angle = gpuTable[ind_t];
  										
  						// check if the current pixel is located in the voting area of this voter.
  						if (((xr * xr + yr *yr)< rmax_sq) && (abs(atan_angle - theta) <phi)){
  							// find the vote value for the current counter
  							float vote_c = gpuVote[(y_v+yr)*x + (x_v+xr)];
  							// compare the vote value of this pixel with the max value to find the maxima and its index.
  							if  (vote_c>max) {
  
  								max = vote_c;
  								id_x =  xr;
  								id_y =  yr;

  							}
  						}
  					}
  				}

  				unsigned int ind_m = (rmax - id_y) * x_table + (rmax - id_x);
  				float new_angle = gpuTable[ind_m];
  				gpuDir[xi] = new_angle;
  			}

  		}

  
  		// this kernel updates the gradient direction by the calculated voting direction.
  		template<typename T>

  		__global__ void cuda_update_grad(T* gpuTh, T* gpuDir, int th_size, int x, int y){

  			// calculate the coordinate for this current thread.

  			int xi = blockIdx.x * blockDim.x + threadIdx.x;

  			//update the gradient image with the vote direction

  			gpuTh[3*xi] = gpuDir[xi];

  		}
  		
  		template<typename T>

  		void gpu_update_dir(T* gpuVote, T* gpuTh, T* gpuTable, T phi, unsigned int rmax, unsigned int th_size, unsigned int x, unsigned int y){

  
  			//calculate the number of bytes in the array

  			unsigned int bytes_th = th_size* sizeof(T);

  
  			unsigned int max_threads = stim::maxThreadsPerBlock();

  			dim3 threads(max_threads);
  			dim3 blocks(th_size/threads.x+1);

  			
  			// allocate space on the GPU for the updated vote direction
  			T* gpuDir;

  			cudaMalloc(&gpuDir, bytes_th);	

  
  			//call the kernel to calculate the new voting direction

  			cuda_update_dir <<< blocks, threads>>>(gpuDir, gpuVote, gpuTh, gpuTable, phi, rmax, th_size, x , y);

  
  			//call the kernel to update the gradient direction

  			cuda_update_grad <<< blocks, threads >>>(gpuTh, gpuDir, th_size, x , y);

  			
  			//free allocated memory
  			cudaFree(gpuDir);
  
  		}
  		
  		template<typename T>
  		void cpu_update_dir(T* cpuVote, T* cpuGrad,T* cpuTable, T phi, unsigned int rmax, unsigned int x, unsigned int y){
  
  			//calculate the number of bytes in the array
  			unsigned int bytes = x * y * sizeof(T);
  
  			//calculate the number of bytes in the atan2 table
  			unsigned int bytes_table = (2*rmax+1) * (2*rmax+1) * sizeof(T);
  
  			//allocate space on the GPU for the Vote Image
  			T* gpuVote;
  			cudaMalloc(&gpuVote, bytes);
  
  			//copy the input vote image to the GPU
  			HANDLE_ERROR(cudaMemcpy(gpuVote, cpuVote, bytes, cudaMemcpyHostToDevice));	
  
  			//allocate space on the GPU for the input Gradient image
  			T* gpuGrad;
  			HANDLE_ERROR(cudaMalloc(&gpuGrad, bytes*2));
  
  			//copy the Gradient data to the GPU
  			HANDLE_ERROR(cudaMemcpy(gpuGrad, cpuGrad, bytes*2, cudaMemcpyHostToDevice));
  
  			//allocate space on the GPU for the atan2 table
  			T* gpuTable;
  			HANDLE_ERROR(cudaMalloc(&gpuTable, bytes_table));
  
  			//copy the atan2 values to the GPU
  			HANDLE_ERROR(cudaMemcpy(gpuTable, cpuTable, bytes_table, cudaMemcpyHostToDevice));
  						
  			//call the GPU version of the update direction function
  			gpu_update_dir<T>(gpuVote, gpuGrad, gpuTable, phi, rmax, x , y);
  							
  			//copy the new gradient image back to the CPU
  			cudaMemcpy(cpuGrad, gpuGrad, bytes*2, cudaMemcpyDeviceToHost) ;
  
  			//free allocated memory
  			cudaFree(gpuTable);
  			cudaFree(gpuVote);
  			cudaFree(gpuGrad);
  		}
  		
  	}
  }
  
  #endif