VecOf2dPoints ImageFileClass::GetCentroidOfHighIntensityPixelsinImage(const std::string &inputImageFileName_) {
Initialize(inputImageFileName_);
ReadImageFile(inputImageFileName_);
VecOf2dPoints centroidPoints = VecOf2dPoints();
if (imageFile == nullptr) {
std::cout << "No Image file found. Please initialize and call the function again" << std::endl;
return centroidPoints;
}
*histogramOfImage = histogramOfImageClass->GetHistogramOfImage(*imageFile);
VecOf2dPoints pixelsOfMaxIntensities = histogramOfImageClass->GetAllPixelswithinMaxIntensityRange();
dbScanClass->ClusterDataPoints(pixelsOfMaxIntensities, 4, 20);
clusteredPoints = dbScanClass->GetClusteredPoints();
dbScanClass->GetCentroidOfClusteredPoints(centroidPoints);
return centroidPoints;
//histogramOfImageClass->DisplayHistogramOfImage();
}
inline void ReadDDS(ImageLoaderParams& ImgInfo)
{
if (!ImageLoader::ReadDDS(ImgInfo))
{
if (ImgInfo.releaseresourcesonerror && ImgInfo.dst)
{
delete[] ImgInfo.dst;
ImgInfo.dst = nullptr;
}
ReadImageFile(ImgInfo);
}
}
ImageLoaderParams LoadMipLevel(const hires_mip_level& item,
const std::function<u8*(size_t, bool)>& bufferdelegate,
bool cacheresult)
{
ImageLoaderParams imgInfo;
imgInfo.releaseresourcesonerror = cacheresult;
imgInfo.dst = nullptr;
imgInfo.Path = item.path.c_str();
imgInfo.request_buffer_delegate = bufferdelegate;
if (item.is_compressed)
{
ReadDDS(imgInfo);
}
else
{
ReadImageFile(imgInfo);
}
return imgInfo;
}
int ImageOperationECB(int argc, char** argv, bool bEncrypt = true)
{
// Parse arguments
// OpenCL arguments: platform and device
cl_int err;
int iPlatform = GetArgInt (argc, argv, "p");
int iDevice = GetArgInt (argc, argv, "d");
char* sInFile = GetArgString(argc, argv, "in");
char* sOutFile = GetArgString(argc, argv, "out");
if (sInFile == NULL || sOutFile == NULL || !FileExists(sInFile))
{
PrintUsage();
return -1;
}
// Initialize ImageMagick
Magick::InitializeMagick(*argv);
ImageData img = ReadImageFile(sInFile);
// Allocate Host Memory
unsigned char key[16] = {
0x2B, 0x7E, 0x15, 0x16,
0x28, 0xAE, 0xD2, 0xA6,
0xAB, 0xF7, 0x15, 0x88,
0x09, 0xCF, 0x4F, 0x3C};
unsigned char* roundKeys = NULL;
int rounds = 0;
ComputeRoundKeys(&roundKeys, &rounds, 16, key);
// Set-up OpenCL Platform
OCL_Device* pOCL_Device = new OCL_Device(iPlatform, iDevice);
pOCL_Device->SetBuildOptions("");
pOCL_Device->PrintInfo();
// Set up OpenCL
cl_kernel Kernel = pOCL_Device->GetKernel("aes-kernel.cl",
bEncrypt ? "AES_ECB_Encrypt" : "AES_ECB_Decrypt");
// Allocate Device Memory
cl_mem d_A = pOCL_Device->DeviceMalloc(0, img.padded_bytes);
cl_mem d_B = pOCL_Device->DeviceMalloc(1, img.padded_bytes);
cl_mem d_C = pOCL_Device->DeviceMalloc(2, rounds * 16);
// Copy Image to Device
pOCL_Device->CopyBufferToDevice(img.data, 0, img.padded_bytes);
// Keys
pOCL_Device->CopyBufferToDevice(roundKeys, 2, rounds * 16);
// Set Kernel Arguments
cl_int _num = img.padded_bytes / 16;
err = clSetKernelArg(Kernel, 0, sizeof(cl_mem), &d_A);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 1, sizeof(cl_mem), &d_B);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 2, sizeof(cl_mem), &d_C);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 3, sizeof(cl_int), &rounds);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 4, sizeof(cl_int), &_num);
CHECK_OPENCL_ERROR(err);
// Wait for previous action to finish
err = clFinish(pOCL_Device->GetQueue());
CHECK_OPENCL_ERROR(err);
size_t off = 0;
size_t num = img.padded_bytes / 16;
size_t threads = 256;
// Run the kernel
err = clEnqueueNDRangeKernel(pOCL_Device->GetQueue(),
Kernel, 1, NULL, &num, &threads, 0, NULL, NULL);
CHECK_OPENCL_ERROR(err);
// Wait for kernel to finish
err = clFinish(pOCL_Device->GetQueue());
CHECK_OPENCL_ERROR(err);
// Copy Data From Device
pOCL_Device->CopyBufferToHost (img.data, 1, img.padded_bytes);
// Free resources
delete pOCL_Device;
delete[] roundKeys;
// Write Output data
WriteImageFile(sOutFile, img);
free(img.data);
return 0;
}
