/**
* This demonstrates homomorphic operations being done
* on images. An input image is encrypted pixelwise and
* homomorphically. Then a homomorphic transformation
* is done on it. In this case we convert the RGB values
* of the pixels of the image to HSV (Hue, Saturation, Value).
* Then we rotate the hue by a constant amount, morphing
* the color of the image. The result is then decrypted
* and displayed next to the original.
*
* Due to the constraints of homomorphic computation the
* image is scaled down to be of size 100 by 100 pixels.
* Then we perform batch homomorphic computation on a
* vector of pixels of size ~10,000.
*/
int main(int argc, char * argv[]) {
if (argc < 2) {
std::cerr << "Usage: " << argv[0] << " ImageFile" << std::endl;
return 1;
}
// Our image input
cimg_library::CImg<unsigned char> img(argv[1]);
clock_t start, end;
start = clock();
// Generate parameters for the YASHE protocol
// and create environment.
YASHE SHE = YASHE::readFromFile("resources/8BitFHE");
//long t = 257;
//NTL::ZZ q = NTL::GenPrime_ZZ(400);
//long d = 22016; // 2^9*43 - 5376 factors
//long sigma = 8;
//NTL::ZZ w = NTL::power2_ZZ(70);
//YASHE SHE(t,q,d,sigma,w);
end = clock();
std::cout << "Reading parameters completed in "
<< double(end - start)/CLOCKS_PER_SEC
<< " seconds"
<< std::endl;
std::cout << SHE.getNumFactors() << " factors." << std::endl;
// Resize the image so we can pack it into a single
// cipher text
if (img.width() * img.height() > SHE.getNumFactors()) {
double scalingFactor = SHE.getNumFactors()/double(img.width() * img.height());
scalingFactor = sqrt(scalingFactor);
long newWidth = img.width() * scalingFactor;
long newHeight = img.height() * scalingFactor;
img.resize(newWidth,newHeight, 1, 3, 5);
}
// Define a color space of 256 colors
cimg_library::CImg<unsigned char> colorMap =
cimg_library::CImg<unsigned char>::default_LUT256();
// Convert the image into a list of integers
// each integer represents a pixel defined
// by the color mapping above.
std::vector<long> message;
ImageFunctions::imageToLongs(message, img, colorMap);
// In order for the output to reflect the
// input we change img to be exactly the
// image we are encrypting - quantized
// to 256 colors.
ImageFunctions::longsToImage(message, img, colorMap);
// Resize the message so that it fills the entire
// message space (the end of it will be junk)
message.resize(SHE.getNumFactors());
// Define a function on pixels.
// This function takes a pixel value (0 - 255)
// and returns another pixel value representing
// the inversion of that pixel value.
std::function<long(long)> invertColors = [colorMap](long input) {
unsigned char r, g, b;
double h, s, v;
ImageFunctions::longToRGB(input, r, g, b, colorMap);
ImageFunctions::RGBtoHSV(r, g, b, &h, &s, &v);
// rotate hue by 30 degrees
h = fmod(h - 75, 360);
//s = pow(s, 4.);
ImageFunctions::HSVtoRGB(&r, &g, &b, h, s, v);
ImageFunctions::RGBToLong(input, r, g, b, colorMap);
return input;
};
// The function is converted into
// a polynomial of degree t = 257
std::vector<long> poly = Functions::functionToPoly(invertColors, 257);
start = clock();
// Generate public, secret and evaluation keys
NTL::ZZ_pX secretKey = SHE.keyGen();
end = clock();
std::cout << "Key generation completed in "
<< double(end - start)/CLOCKS_PER_SEC
<< " seconds"
<< std::endl;
start = clock();
// encrypt the message
YASHE_CT ciphertext = SHE.encryptBatch(message);
end = clock();
std::cout << "Encryption completed in "
<< double(end - start)/CLOCKS_PER_SEC
<< " seconds"
<< std::endl;
start = clock();
// evaluate the polynomial
YASHE_CT::evalPoly(ciphertext, ciphertext, poly);
end = clock();
std::cout << "Polynomial evaluation completed in "
<< double(end - start)/CLOCKS_PER_SEC
<< " seconds"
<< std::endl;
start = clock();
// decrypt the message
std::vector<long> decryption = SHE.decryptBatch(ciphertext, secretKey);
end = clock();
std::cout << "Decryption completed in "
<< double(end - start)/CLOCKS_PER_SEC
<< " seconds"
<< std::endl;
// turn the message back into an image
cimg_library::CImg<unsigned char> outputImg(img.width(), img.height(), 1, 3);
ImageFunctions::longsToImage(decryption, outputImg, colorMap);
// Display the input next to the output!
(img, outputImg).display("result!",false);
return 0;
}
int main(int argc, char *argv[])
{
/**
* Print the Help
*/
if (argc < 2) {
fprintf(stderr,"Usage:""\n%s imageData1 imageData2", argv[0]);
fprintf(stderr," or:""\n%s camera", argv[0]);
fprintf(stderr, "\n\ngeneral usage further parameters: -option number\n");
fprintf(stderr, "-l -lambda \t\t defines lambda [default=5.0]\n");
fprintf(stderr, "-oi -outeriterations \t defines outeriterations [default=40]\n");
fprintf(stderr, "-ii -inneriterations \t defines inneriterations [default=2]\n");
fprintf(stderr, "-sl -startlevel \t defines startlevel [default=3]\n");
fprintf(stderr, "-el -endlevel \t\t defines endlevel [default=0]\n");
fprintf(stderr, "-cd -computationdevice defines the computation device [default=0], 0 = CPU, 1 = GPU\n");
fprintf(stderr, "-w -width \t\t defines camera capture size [default=320]\n");
fprintf(stderr,"\n\n");
return 0;
}
/**
* Standard Parameters
*/
int start_level = 3;
int end_level = 0;
int outer_iterations = 40;
int inner_iterations = 2;
float lambda = 0.2f;
int cameraWidth = 320, cameraHeight = 240;
int computationDevice = 0;
std::string partype = "";
std::string parval = "";
std::string arg1 = argv[1];
/**
* Read Parameters from Input
*/
int parnum;
if (arg1 != "camera")
parnum = 3;
else
parnum = 2;
while(parnum < argc) {
partype = argv[parnum++];
if(partype == "-l" || partype == "-lambda") {
lambda = (float)atof(argv[parnum++]);
fprintf(stderr,"\nSmoothness Weight: %f", lambda);
}
else if(partype == "-oi" || partype == "-outeriterations") {
outer_iterations = atoi(argv[parnum++]);
fprintf(stderr,"\nOuter Iterations: %i", outer_iterations);
}
else if(partype == "-ii" || partype == "-inneriterations") {
inner_iterations = atoi(argv[parnum++]);
fprintf(stderr,"\nInner Iterations: %i", inner_iterations);
}
else if(partype == "-sl" || partype == "-startlevel") {
start_level = atoi(argv[parnum++]);
fprintf(stderr,"\nStart Level: %i", start_level);
}
else if(partype == "-el" || partype == "-endlevel") {
end_level = atoi(argv[parnum++]);
fprintf(stderr,"\nEnd Level: %i", end_level);
}
else if ((partype == "-w" || partype == "-width") && strcmp(argv[1], "camera") == 0) {
cameraWidth = atoi(argv[parnum++]);
cameraHeight = (int)(cameraWidth*3/4);
fprintf(stderr,"\nCamera Width: %i\nCamera Height: %i", cameraWidth, cameraHeight);
}
else if(partype == "-cd"|| partype == "-computationdevice"){
std::string parval = argv[parnum++];
if(parval == "0")computationDevice = 0;
if(parval == "1")computationDevice = 1;
fprintf(stderr,"\nComputation Device: %s",computationDevice ? "GPU" : "CPU");
}
}
if (arg1 != "camera" && arg1 != "video") {
cv::Mat img1 = cv::imread(argv[1], 0); // 0 = force the image to be grayscale
cv::Mat img2 = cv::imread(argv[2], 0);
if (img1.rows != img2.rows || img1.cols != img2.cols) {
fprintf(stderr,
"\nError: Image formats are not equal: (%i|%i) vs. (%i|%i)",
img1.cols,img1.rows,img2.cols,img2.rows);
return 1;
}
fprintf(stderr,"\nInput Image Dimensions: (%i|%i)",img1.cols,img1.rows);
img1.convertTo(img1,CV_32FC1);
img2.convertTo(img2,CV_32FC1);
fprintf(stderr,"\nCreating FlowLib Object");
FlowLib *flowlib = NULL;
if(computationDevice == 1)
flowlib = new FlowLibGpuSOR(img1.cols,img1.rows);
else if(computationDevice == 0)
flowlib = new FlowLibCpuSOR(img1.cols,img1.rows);
fprintf(stderr,"\nSetting up Flow");
flowlib->setLambda(lambda);
flowlib->setOuterIterations(outer_iterations);
flowlib->setInnerIterations(inner_iterations);
flowlib->setStartLevel(start_level);
flowlib->setEndLevel(end_level);
flowlib->setInput((float*)img1.data);
flowlib->setInput((float*)img2.data);
fprintf(stderr,"\nComputing Flow");
flowlib->computeFlow();
float *u = new float[img1.cols*img1.rows*2];
float *v = new float[img1.cols*img1.rows];
flowlib->getOutput(u,v);
for(int x=img1.cols*img1.rows-1;x>=0;x--){
u[2*x] = u[x];
u[2*x+1] = v[x];
}
save_flow_file("output.flo",u, img1.cols, img1.rows);
delete [] u;
fprintf(stderr,"\nDisplaying Output");
cv::Mat outputImg(cv::Size(img1.cols,img1.rows),CV_32FC3);
flowlib->getOutputBGR((float*)outputImg.data,0.0f,1.0f,0.0f,1.0f);
cv::imshow("Input Image 1",img1/255.0f);
cv::imshow("Input Image 2",img2/255.0f);
cv::imshow("Output Image",outputImg);
cv::imwrite(computationDevice ? "flowImageGPU.png" : "flowImageCPU.png",outputImg*255.0f);
cvMoveWindow("Input Image 1", 100, 100);
cvMoveWindow("Input Image 2", 450, 100);
cvMoveWindow("Output Image", 100, 400);
printf("\nPress Esc on the image to exit...\n");
cv::waitKey(0);
fprintf(stderr,"\nDeleting Flow Object");
delete flowlib;
fprintf(stderr,"\nFlow Object Deleted.");
} // endif image file
//----------------------------------------------------------------------------
// Camera Mode
//----------------------------------------------------------------------------
else{
cv::VideoCapture *capture = 0;
bool videomode = arg1 == "video";
if(videomode){
fprintf(stderr,"\nReading Images from Video %s",argv[2]);
capture = new cv::VideoCapture(argv[2]);
}
else{
fprintf(stderr,"\nReading Images from Camera");
capture = new cv::VideoCapture(0);
}
if(!capture->isOpened()){
std::cerr << std::endl << "Could not Open Capture Device";
return -1;
}
if(!videomode){
fprintf(stderr,"\nSetting Camera up to (%i|%i)",cameraWidth,cameraHeight);
capture->set(CV_CAP_PROP_FRAME_WIDTH,cameraWidth);
capture->set(CV_CAP_PROP_FRAME_HEIGHT,cameraHeight);
}
cv::Mat *img1 = new cv::Mat();
cv::Mat *img2 = new cv::Mat();
(*capture) >> (*img1);
fprintf(stderr,"\nImage Dimensions: (%i|%i)",img1->cols,img1->rows);
float *u = new float[img1->cols*img1->rows*2];
float *v = new float[img1->cols*img1->rows];
fprintf(stderr,"\nCreating FlowLib Object");
FlowLib *flowlib = NULL;
if(computationDevice == 1)
flowlib = new FlowLibGpuSOR(img1->cols,img1->rows);
else if(computationDevice == 0)
flowlib = new FlowLibCpuSOR(img1->cols,img1->rows);
fprintf(stderr,"\nFlowLib Object created.");
fprintf(stderr,"\nSetting up Flow");
flowlib->setLambda(lambda);
flowlib->setOuterIterations(outer_iterations);
flowlib->setInnerIterations(inner_iterations);
flowlib->setStartLevel(start_level);
flowlib->setEndLevel(end_level);
fprintf(stderr,"\nFlow Setup Finished");
cv::namedWindow("Input Image",1);
cv::namedWindow("Flow",1);
cv::Mat outputImg(cv::Size(img1->cols,img1->rows),CV_32FC3);
// int counter = 0;
while (cv::waitKey(30) < 0
){
(*capture) >> (*img1);
cv::cvtColor(*img1,*img1,CV_BGR2GRAY);
img1->convertTo(*img1,CV_32FC1);
flowlib->setInput((float*)img1->data);
printf("\n%f fps",1000.0f/flowlib->computeFlow());
flowlib->getOutputBGR((float*)outputImg.data,0.0f,5.0f,0.0f,1.0f);
cv::imshow("Input Image",(*img1)/255.0f);
cv::imshow("Flow",outputImg);
cv::Mat *temp = img1; img1 = img2; img2 = temp;
}
delete capture;
delete [] u;
delete [] v;
} // endif camera
fprintf(stderr,"\n\n");
return 0;
}
void VehicleDetectionSystem::update(const cv::Mat* a_imageFrame,
std::shared_ptr<std::vector<std::shared_ptr<DetectedVehicle>>> verifiedVehicles,
double timeStamp)
{
//clock_t timeBegin = clock();
// Save a copy of the source image so that we don't change the original one
cv::Mat srcImg(a_imageFrame->size(), a_imageFrame->type());
a_imageFrame->copyTo(srcImg);
//cv::Mat srcImg = a_imageFrame->clone();
cv::resize(srcImg, srcImg, cv::Size(m_windowWidth, m_windowHeight),
0, 0, cv::INTER_CUBIC);
cv::Mat outputImg(srcImg.size(), srcImg.type());
srcImg.copyTo(outputImg);
//cv::Mat outputImg = srcImg.clone();
//GaussianBlur(srcImg, srcImg, cv::Size(3,3), 1);
// Extract the sub image of the region of interest
cv::Mat imageROI = srcImg(m_regionOfInterest);
m_haarClassifier.detectMultiScale(imageROI, m_potentialVehicles);
//haarClassifier.detectMultiScale(imageROI, detectedVehicles, 1.03, 3, 0 | CASCADE_FIND_BIGGEST_OBJECT, Size(10, 10), Size(150, 150));
//haarClassifier.detectMultiScale(imageROI, detectedVehicles, 1.03, 1, 0, Size(10, 10), Size(150, 150));
//haarClassifier.detectMultiScale(imageROI, detectedVehicles, 1.1, 3, 0 | CASCADE_FIND_BIGGEST_OBJECT, Size(20, 20), Size(150, 150));
//clock_t timeHaar = clock();
//std::cout << " Detected " << m_potentialVehicles.size() << " potential vehicles\n";
cv::Mat subImage;
std::cout << "Potential #vehicles: " << m_potentialVehicles.size() <<
std::endl;
for (size_t i = 0; i < m_potentialVehicles.size(); i++) {
//cout << "Inside for loop \n";
cv::Rect r = m_potentialVehicles[i];
r.y += m_roiTop;
//cv::imshow("Debug", srcImg(r));
//cv::waitKey(0);
//cv::Mat featureMat(nrOfFeatures, 1, CV_32FC1, featureVector);
subImage = cv::Mat(srcImg(r).size(), srcImg(r).type());
srcImg(r).copyTo(subImage);
//subImage = srcImg(r).clone();
float result = m_ann.doClassification(&subImage);
std::cout << "ann result: " << result << std::endl;
bool saveImages = false;
std::string saveImgPath = "tmp_img/";
if (result > 0) {
// if this subimage gets verified by SVM, draw green
cv::rectangle(outputImg, r, cv::Scalar(0,255,0));
std::shared_ptr<DetectedVehicle> detectedVehicle(
new DetectedVehicle(r, timeStamp));
verifiedVehicles->push_back(detectedVehicle);
if (saveImages) {
std::string imgFileName = saveImgPath + "pos" +
std::to_string(m_imgCounter) + ".jpg";
imwrite(imgFileName, subImage);
m_imgCounter++;
}
} else {
// otherwise, if not verified, draw gray
cv::rectangle(outputImg, r, cv::Scalar(0,0,255));
if (saveImages) {
std::string imgFileName = saveImgPath + "neg" +
std::to_string(m_imgCounter) + ".jpg";
imwrite(imgFileName, subImage);
m_imgCounter++;
}
}
//std::cout << "ANN response: " << result << "\n";
//cv::imshow("Debug", subImage);
//cv::waitKey(10);
//cv::rectangle(outputImg, r, cv::Scalar(0,255,0));
subImage.release();
}
//clock_t timeAnn = clock();
//float f_timeHaar = (float) (timeHaar-timeBegin)/CLOCKS_PER_SEC;
//float f_timeAnn = (float) (timeAnn-timeHaar)/CLOCKS_PER_SEC;
//std::cout << " (timeHaar, timeAnn): (" << f_timeHaar << ", " << f_timeAnn << ")\n";
// Create the window
//cv::imshow("VehicleDetectionSystem", outputImg);
//cv::moveWindow("VehicleDetectionSystem", 100, 100);
//cv::waitKey(10);
subImage.release();
imageROI.release();
outputImg.release();
srcImg.release();
}
void FaceFeatureRecognitionApp::GenerateFalsePositives(void)
{
std::string fileName;
char filterName[] = "Land Files(*.txt)\0*.txt\0";
MagicCore::ToolKit::FileOpenDlg(fileName, filterName);
std::string imgPath = fileName;
std::string::size_type pos = imgPath.rfind("/");
if (pos == std::string::npos)
{
pos = imgPath.rfind("\\");
}
imgPath.erase(pos);
std::ifstream fin(fileName);
int dataSize;
fin >> dataSize;
const int maxSize = 512;
char pLine[maxSize];
fin.getline(pLine, maxSize);
double maxOverlapRate = 0.5;
std::string outputPath = "./NonFacefw2/nonFace2_fw_";
int outputSize = 32;
int outputId = 0;
for (int dataId = 0; dataId < dataSize; dataId++)
{
DebugLog << "dataId: " << dataId << " dataSize: " << dataSize << std::endl;
fin.getline(pLine, maxSize);
std::string landName(pLine);
landName = imgPath + landName;
std::string imgName = landName;
std::string posName = landName;
std::string::size_type pos = imgName.rfind(".");
imgName.replace(pos, 5, ".jpg");
pos = posName.rfind(".");
posName.replace(pos, 5, ".pos");
std::ifstream posFin(posName);
int faceRow, faceCol, faceLen;
posFin >> faceRow >> faceCol >> faceLen;
posFin.close();
cv::Mat img = cv::imread(imgName);
cv::Size cvHalfSize(img.cols / 2, img.rows / 2);
cv::Mat halfImg(cvHalfSize, CV_8UC1);
cv::resize(img, halfImg, cvHalfSize);
//cv::Mat halfImg = cv::imread(imgName);
std::vector<int> faces;
int detectNum = mpFaceDetection->DetectFace(halfImg, faces);
for (int detectId = 0; detectId < detectNum; detectId++)
{
int detectBase = detectId * 4;
int detectRow = faces.at(detectBase);
int detectCol = faces.at(detectBase + 1);
int detectLen = faces.at(detectBase + 2);
if (CalculateOverlapRate(faceRow, faceCol, faceLen, detectRow, detectCol, detectLen) < maxOverlapRate)
{
cv::Mat detectImg(detectLen, detectLen, CV_8UC1);
for (int hid = 0; hid < detectLen; hid++)
{
for (int wid = 0; wid < detectLen; wid++)
{
detectImg.ptr(hid, wid)[0] = halfImg.ptr(detectRow + hid, detectCol + wid)[0];
}
}
cv::Size cvOutputSize(outputSize, outputSize);
cv::Mat outputImg(cvOutputSize, CV_8UC1);
cv::resize(detectImg, outputImg, cvOutputSize);
detectImg.release();
std::stringstream ss;
ss << outputPath << outputId << ".jpg";
std::string outputImgName;
ss >> outputImgName;
outputId++;
cv::imwrite(outputImgName, outputImg);
outputImg.release();
}
}
halfImg.release();
}
void FaceFeatureRecognitionApp::GenerateNonFaceFromFace(void)
{
std::string fileName;
char filterName[] = "Land Files(*.txt)\0*.txt\0";
MagicCore::ToolKit::FileOpenDlg(fileName, filterName);
std::string imgPath = fileName;
std::string::size_type pos = imgPath.rfind("/");
if (pos == std::string::npos)
{
pos = imgPath.rfind("\\");
}
imgPath.erase(pos);
std::ifstream fin(fileName);
int dataSize;
fin >> dataSize;
int cropSize = 40;
int outputSize = 64;
cv::Size cvOutputSize(outputSize, outputSize);
int imgNumPerData = 1;
srand(time(NULL));
for (int dataId = 0; dataId < dataSize; dataId++)
{
std::string imgName;
fin >> imgName;
imgName = imgPath + imgName;
pos = imgName.rfind(".");
imgName.replace(pos, 5, "_gray.jpg");
/*cv::Mat imgOrigin = cv::imread(imgName);
cv::Mat grayImg;
cv::cvtColor(imgOrigin, grayImg, CV_BGR2GRAY);
imgOrigin.release();*/
cv::Mat grayImg = cv::imread(imgName);
int imgH = grayImg.rows;
int hMax = imgH - cropSize;
int imgW = grayImg.cols;
int wMax = imgW - cropSize;
int synImgNum = 0;
while (synImgNum < imgNumPerData)
{
int sH = rand() % hMax;
int sW = rand() % wMax;
cv::Mat cropImg(cropSize, cropSize, CV_8UC1);
for (int hid = 0; hid < cropSize; hid++)
{
for (int wid = 0; wid < cropSize; wid++)
{
cropImg.ptr(hid, wid)[0] = grayImg.ptr(sH + hid, sW + wid)[0];
}
}
cv::Mat outputImg(cvOutputSize, CV_8UC1);
cv::resize(cropImg, outputImg, cvOutputSize);
cropImg.release();
std::stringstream ss;
ss << "./nonFaceFromFace/nonFace" << dataId << "_" << synImgNum << "_40.jpg";
std::string outputName;
ss >> outputName;
cv::imwrite(outputName, outputImg);
outputImg.release();
synImgNum++;
}
grayImg.release();
}
fin.close();
DebugLog << "GenerateNonFaceFromFace Done" << std::endl;
}
cv::Mat image2vectors_single(cv::Mat img,
int neighborhoodRadius,
int nThreads)
{
assert(CV_32FC1 == img.type());
assert(img.isContinuous());
/* Input image, output image */
float *I, *V;
float *K;
/* Size of input image */
int Isize[3]={1, 1, 1};
int ndimsI = 2;
/* Size of vector volume */
int nVsize=2;
int Vsize[2];
int indexV=0;
/* Constants used */
int kernelratio=3;
int kernelsize;
int block[6]={1, 1, 1, 1, 1, 1};
int block_size[3];
int image3D;
/* Loop variable */
int i;
float Isize_d[3];
float Vsize_d[3];
float par_d[4];
float block_d[6];
int Nthreads;
/* float pointer array to store all needed function variables) */
float ***ThreadArgs;
float **ThreadArgs1;
/* Handles to the worker threads */
#ifdef _WIN32
HANDLE *ThreadList;
#else
pthread_t *ThreadList;
#endif
/* ID of Threads */
float **ThreadID;
float *ThreadID1;
/* Check input image dimensions */
Isize[0]=img.size().width;
Isize[1]=img.size().height;
if(Isize[2]>3) { image3D=1; } else { image3D=0; }
/* Connect input image */
I = reinterpret_cast<float*>(img.data);
/* Set Values */
kernelratio = neighborhoodRadius;
kernelsize=2*kernelratio+1;
if(image3D==0) {
block[0]=kernelratio;
block[1]=kernelratio;
block[2]=Isize[0]-kernelratio-1;
block[3]=Isize[1]-kernelratio-1;
block_size[0]=block[2]-block[0]+1;
block_size[1]=block[3]-block[1]+1;
Vsize[0]=kernelsize*kernelsize*Isize[2];
Vsize[1]=block_size[0]*block_size[1];
}
else {
block[0]=kernelratio;
block[1]=kernelratio;
block[2]=kernelratio;
block[3]=Isize[0]-kernelratio-1;
block[4]=Isize[1]-kernelratio-1;
block[5]=Isize[2]-kernelratio-1;
block_size[0]=block[3]-block[0]+1;
block_size[1]=block[4]-block[1]+1;
block_size[2]=block[5]-block[2]+1;
Vsize[0]=kernelsize*kernelsize*kernelsize;
Vsize[1]=block_size[0]*block_size[1]*block_size[2];
}
/* Create output array */
cv::Mat outputImg(Vsize[1], Vsize[0], CV_32FC1);
V = reinterpret_cast<float*>(outputImg.data);
if(image3D==0) {
K = gaussian_kernel_2D(kernelratio);
for (i=0; i<(kernelsize*kernelsize); i++) { K[i]=(float)sqrt(K[i]); }
}
else {
K = gaussian_kernel_3D(kernelratio);
for (i=0; i<(kernelsize*kernelsize*kernelsize); i++) { K[i]=(float)sqrt(K[i]); }
}
Nthreads = nThreads;
float nThreadsF = static_cast<float>(nThreads);
/* Reserve room for handles of threads in ThreadList */
#ifdef _WIN32
ThreadList = (HANDLE*)malloc(Nthreads* sizeof( HANDLE ));
#else
ThreadList = (pthread_t*)malloc(Nthreads* sizeof( pthread_t ));
#endif
ThreadID = (float **)malloc( Nthreads* sizeof(float *) );
ThreadArgs = (float ***)malloc( Nthreads* sizeof(float **) );
for(i=0; i<3; i++) {
Isize_d[i]=(float)Isize[i];
Vsize_d[i]=(float)Vsize[i];
block_d[i] =(float)block[i];
block_d[i+3] =(float)block[i+3];
}
par_d[0] =(float)kernelratio;
par_d[1] =(float)image3D;
for (i=0; i<Nthreads; i++) {
/* Make Thread ID */
ThreadID1= (float *)malloc( 1* sizeof(float) );
ThreadID1[0]=(float)i;
ThreadID[i]=ThreadID1;
/* Make Thread Structure */
ThreadArgs1 = (float **)malloc( 9* sizeof( float * ) );
ThreadArgs1[0]=I;
ThreadArgs1[1]=Isize_d;
ThreadArgs1[2]=V;
ThreadArgs1[3]=Vsize_d;
ThreadArgs1[4]=par_d;
ThreadArgs1[5]=block_d;
ThreadArgs1[6]=K;
ThreadArgs1[7]=ThreadID[i];
ThreadArgs1[8]=&nThreadsF;
/* Start a Thread */
ThreadArgs[i]=ThreadArgs1;
#ifdef _WIN32
ThreadList[i] = (HANDLE)_beginthreadex( NULL, 0, reinterpret_cast<unsigned int (__stdcall *)(void *)>(&getvectors_multi_threaded), ThreadArgs[i] , 0, NULL );
#else
pthread_create((pthread_t*)&ThreadList[i], NULL, (void *) &getvectors_multi_threaded, ThreadArgs[i]);
#endif
}
#ifdef _WIN32
for (i=0; i<Nthreads; i++) { WaitForSingleObject(ThreadList[i], INFINITE); }
for (i=0; i<Nthreads; i++) { CloseHandle( ThreadList[i] ); }
#else
for (i=0; i<Nthreads; i++) { pthread_join(ThreadList[i], NULL); }
#endif
for (i=0; i<Nthreads; i++) {
free(ThreadArgs[i]);
free(ThreadID[i]);
}
free(ThreadArgs);
free(ThreadID );
free(ThreadList);
free(K);
return outputImg;
}
