void setScalarAsFloat(T* data, uint position, Image::pointer image, float value, uchar channel) { Vector3ui size = image->getSize(); if(position >= size.x()*size.y()*size.z()) throw OutOfBoundsException(); uint address = position*image->getNrOfComponents() + channel; if(image->getDataType() == TYPE_SNORM_INT16) { data[address] = value * 32767.0f;; } else if(image->getDataType() == TYPE_UNORM_INT16) { data[address] = value * 65535.0f;; } else { data[address] = value; } }
float getScalarAsFloat(T* data, uint position, Image::pointer image, uchar channel) { Vector3ui size = image->getSize(); if(position >= size.x()*size.y()*size.z()) throw OutOfBoundsException(); T value = data[position*image->getNrOfComponents() + channel]; float floatValue; if(image->getDataType() == TYPE_SNORM_INT16) { floatValue = std::max(-1.0f, (float)value / 32767.0f); } else if(image->getDataType() == TYPE_UNORM_INT16) { floatValue = (float)value / 65535.0f; } else { floatValue = value; } return floatValue; }
/* void NoneLocalMeans::recompileOpenCLCode(Image::pointer input) { // Check if there is a need to recompile OpenCL code if (input->getDimensions() == mDimensionCLCodeCompiledFor && input->getDataType() == mTypeCLCodeCompiledFor && !recompile) return; OpenCLDevice::pointer device = getMainDevice(); recompile = false; std::string buildOptions = ""; const bool writingTo3DTextures = device->getDevice().getInfo<CL_DEVICE_EXTENSIONS>().find("cl_khr_3d_image_writes") != std::string::npos; if (!writingTo3DTextures) { switch (mOutputType) { case TYPE_FLOAT: buildOptions += " -DTYPE=float"; break; case TYPE_INT8: buildOptions += " -DTYPE=char"; break; case TYPE_UINT8: buildOptions += " -DTYPE=uchar"; break; case TYPE_INT16: buildOptions += " -DTYPE=short"; break; case TYPE_UINT16: buildOptions += " -DTYPE=ushort"; break; } } buildOptions += " -D WINDOW="; buildOptions += std::to_string((windowSize-1)/2); buildOptions += " -D GROUP="; buildOptions += std::to_string((groupSize-1)/2); std::string filename; //might have to seperate color vs gray here, for better runtime if (input->getDimensions() == 2) { if(k == 0){ filename = "Algorithms/NoneLocalMeans/NoneLocalMeans2Dconstant.cl"; }else if(k == 1){ filename = "Algorithms/NoneLocalMeans/NoneLocalMeans2Dgaussian.cl"; }else{ filename = "Algorithms/NoneLocalMeans/NoneLocalMeans2Dconstant.cl"; } //filename = "Algorithms/NoneLocalMeans/NoneLocalMeans2DgsPixelWise.cl"; //filename = "Algorithms/NoneLocalMeans/NoneLocalMeans2Dgs.cl"; //filename = "Algorithms/NoneLocalMeans/NoneLocalMeans2Dc.cl"; } else { filename = "Algorithms/NoneLocalMeans/NoneLocalMeans3Dgs.cl"; } int programNr = device->createProgramFromSource(std::string(FAST_SOURCE_DIR) + filename, buildOptions); mKernel = cl::Kernel(device->getProgram(programNr), "noneLocalMeans"); mDimensionCLCodeCompiledFor = input->getDimensions(); mTypeCLCodeCompiledFor = input->getDataType(); }*/ void NoneLocalMeans::execute() { Image::pointer input = getStaticInputData<Image>(0); Image::pointer output = getStaticOutputData<Image>(0); // Initialize output image ExecutionDevice::pointer device = getMainDevice(); if(mOutputTypeSet) { output->create(input->getSize(), mOutputType, input->getNrOfComponents()); output->setSpacing(input->getSpacing()); } else { output->createFromImage(input); } mOutputType = output->getDataType(); SceneGraph::setParentNode(output, input); if(device->isHost()) { switch(input->getDataType()) { fastSwitchTypeMacro(executeAlgorithmOnHost<FAST_TYPE>(input, output, groupSize, windowSize, denoiseStrength, sigma)); } } else { OpenCLDevice::pointer clDevice = device; recompileOpenCLCode(input); cl::NDRange globalSize; OpenCLImageAccess::pointer inputAccess = input->getOpenCLImageAccess(ACCESS_READ, device); if(input->getDimensions() == 2) { OpenCLImageAccess::pointer outputAccess = output->getOpenCLImageAccess(ACCESS_READ_WRITE, device); mKernel.setArg(2, (denoiseStrength*denoiseStrength)); mKernel.setArg(3, (sigma*sigma)); globalSize = cl::NDRange(input->getWidth(),input->getHeight()); mKernel.setArg(0, *inputAccess->get2DImage()); mKernel.setArg(1, *outputAccess->get2DImage()); clDevice->getCommandQueue().enqueueNDRangeKernel( mKernel, cl::NullRange, globalSize, cl::NullRange ); } else { // Create an auxilliary image //Image::pointer output2 = Image::New(); //output2->createFromImage(output); globalSize = cl::NDRange(input->getWidth(),input->getHeight(),input->getDepth()); if(clDevice->isWritingTo3DTexturesSupported()) { mKernel.setArg(2, (denoiseStrength*denoiseStrength)); mKernel.setArg(3, (sigma*sigma)); OpenCLImageAccess::pointer outputAccess = output->getOpenCLImageAccess(ACCESS_READ_WRITE, device); //OpenCLImageAccess::pointer outputAccess2 = output2->getOpenCLImageAccess(ACCESS_READ_WRITE, device); //cl::Image3D* image2; cl::Image3D* image; image = outputAccess->get3DImage(); //image2 = outputAccess->get3DImage(); mKernel.setArg(0, *inputAccess->get3DImage()); mKernel.setArg(1, *image); clDevice->getCommandQueue().enqueueNDRangeKernel( mKernel, cl::NullRange, globalSize, cl::NullRange ); }else{ mKernel.setArg(2, (denoiseStrength*denoiseStrength)); mKernel.setArg(3, (sigma*sigma)); OpenCLBufferAccess::pointer outputAccess = output->getOpenCLBufferAccess(ACCESS_READ_WRITE, device); mKernel.setArg(0, *inputAccess->get3DImage()); mKernel.setArg(1, *outputAccess->get()); clDevice->getCommandQueue().enqueueNDRangeKernel( mKernel, cl::NullRange, globalSize, cl::NullRange ); } } } }
void DoubleFilter::execute() { if(!mInput.isValid()) { throw Exception("No input supplied to GaussianSmoothingFilter"); } Image::pointer input = mInput; Image::pointer output = mOutput; // Initialize output image output->createFromImage(input, mDevice); if(mDevice->isHost()) { // Execution device is Host, use the executeAlgorithmOnHost function with the given data type switch(input->getDataType()) { // This macro creates a case statement for each data type and sets FAST_TYPE to the correct C++ data type fastSwitchTypeMacro(executeAlgorithmOnHost<FAST_TYPE>(input, output)); } } else { // Execution device is an OpenCL device OpenCLDevice::pointer device = boost::static_pointer_cast<OpenCLDevice>(mDevice); // Set build options based on the data type of the data std::string buildOptions = ""; switch(input->getDataType()) { case TYPE_FLOAT: buildOptions = "-DTYPE=float"; break; case TYPE_INT8: buildOptions = "-DTYPE=char"; break; case TYPE_UINT8: buildOptions = "-DTYPE=uchar"; break; case TYPE_INT16: buildOptions = "-DTYPE=short"; break; case TYPE_UINT16: buildOptions = "-DTYPE=ushort"; break; } // Compile the code int programNr = device->createProgramFromSource(std::string(FAST_SOURCE_DIR) + "Tests/Algorithms/DoubleFilter.cl", buildOptions); cl::Kernel kernel = cl::Kernel(device->getProgram(programNr), "doubleFilter"); // Get global size for the kernel cl::NDRange globalSize(input->getWidth()*input->getHeight()*input->getDepth()*input->getNrOfComponents()); // Set the arguments for the kernel OpenCLBufferAccess inputAccess = input->getOpenCLBufferAccess(ACCESS_READ, device); OpenCLBufferAccess outputAccess = output->getOpenCLBufferAccess(ACCESS_READ_WRITE, device); kernel.setArg(0, *inputAccess.get()); kernel.setArg(1, *outputAccess.get()); // Execute the kernel device->getCommandQueue().enqueueNDRangeKernel( kernel, cl::NullRange, globalSize, cl::NullRange ); } // Update timestamp of the output data output->updateModifiedTimestamp(); }
void executeAlgorithmOnHost(Image::pointer input, Image::pointer output) { ImageAccess inputAccess = input->getImageAccess(ACCESS_READ); ImageAccess outputAccess = output->getImageAccess(ACCESS_READ_WRITE); T * inputData = (T*)inputAccess.get(); T * outputData = (T*)outputAccess.get(); unsigned int nrOfElements = input->getWidth()*input->getHeight()*input->getDepth()*input->getNrOfComponents(); for(unsigned int i = 0; i < nrOfElements; i++) { outputData[i] = 2.0*inputData[i]; } }
void SeededRegionGrowing::execute() { if(mSeedPoints.size() == 0) throw Exception("No seed points supplied to SeededRegionGrowing"); Image::pointer input = getStaticInputData<Image>(); if(input->getNrOfComponents() != 1) throw Exception("Seeded region growing currently doesn't support images with several components."); Segmentation::pointer output = getStaticOutputData<Segmentation>(); // Initialize output image output->createFromImage(input, getMainDevice()); if(getMainDevice()->isHost()) { ImageAccess::pointer inputAccess = input->getImageAccess(ACCESS_READ); void* inputData = inputAccess->get(); switch(input->getDataType()) { fastSwitchTypeMacro(executeOnHost<FAST_TYPE>((FAST_TYPE*)inputData, output)); } } else { OpenCLDevice::pointer device = getMainDevice(); recompileOpenCLCode(input); ImageAccess::pointer access = output->getImageAccess(ACCESS_READ_WRITE); uchar* outputData = (uchar*)access->get(); // Initialize to all 0s memset(outputData,0,sizeof(uchar)*output->getWidth()*output->getHeight()*output->getDepth()); // Add sedd points for(int i = 0; i < mSeedPoints.size(); i++) { Vector3ui pos = mSeedPoints[i]; // Check if seed point is in bounds if(pos.x() < 0 || pos.y() < 0 || pos.z() < 0 || pos.x() >= output->getWidth() || pos.y() >= output->getHeight() || pos.z() >= output->getDepth()) throw Exception("One of the seed points given to SeededRegionGrowing was out of bounds."); outputData[pos.x() + pos.y()*output->getWidth() + pos.z()*output->getWidth()*output->getHeight()] = 2; } access->release(); cl::NDRange globalSize; if(output->getDimensions() == 2) { globalSize = cl::NDRange(input->getWidth(),input->getHeight()); OpenCLImageAccess2D::pointer inputAccess = input->getOpenCLImageAccess2D(ACCESS_READ, device); mKernel.setArg(0, *inputAccess->get()); } else { globalSize = cl::NDRange(input->getWidth(),input->getHeight(), input->getDepth()); OpenCLImageAccess3D::pointer inputAccess = input->getOpenCLImageAccess3D(ACCESS_READ, device); mKernel.setArg(0, *inputAccess->get()); } OpenCLBufferAccess::pointer outputAccess = output->getOpenCLBufferAccess(ACCESS_READ_WRITE, device); cl::Buffer stopGrowingBuffer = cl::Buffer( device->getContext(), CL_MEM_READ_WRITE, sizeof(char)); cl::CommandQueue queue = device->getCommandQueue(); mKernel.setArg(1, *outputAccess->get()); mKernel.setArg(2, stopGrowingBuffer); mKernel.setArg(3, mMinimumIntensity); mKernel.setArg(4, mMaximumIntensity); bool stopGrowing = false; char stopGrowingInit = 1; char * stopGrowingResult = new char; int iterations = 0; do { iterations++; queue.enqueueWriteBuffer(stopGrowingBuffer, CL_TRUE, 0, sizeof(char), &stopGrowingInit); queue.enqueueNDRangeKernel( mKernel, cl::NullRange, globalSize, cl::NullRange ); queue.enqueueReadBuffer(stopGrowingBuffer, CL_TRUE, 0, sizeof(char), stopGrowingResult); if(*stopGrowingResult == 1) stopGrowing = true; } while(!stopGrowing); } }
void ImageSlicer::orthogonalSlicing(Image::pointer input, Image::pointer output) { OpenCLDevice::pointer device = getMainDevice(); // Determine slice nr and width and height unsigned int sliceNr; if(mOrthogonalSliceNr < 0) { switch(mOrthogonalSlicePlane) { case PLANE_X: sliceNr = input->getWidth()/2; break; case PLANE_Y: sliceNr = input->getHeight()/2; break; case PLANE_Z: sliceNr = input->getDepth()/2; break; } } else { // Check that mSliceNr is valid sliceNr = mOrthogonalSliceNr; switch(mOrthogonalSlicePlane) { case PLANE_X: if(sliceNr >= input->getWidth()) sliceNr = input->getWidth()-1; break; case PLANE_Y: if(sliceNr >= input->getHeight()) sliceNr = input->getHeight()-1; break; case PLANE_Z: if(sliceNr >= input->getDepth()) sliceNr = input->getDepth()-1; break; } } unsigned int slicePlaneNr, width, height; Vector3f spacing(0,0,0); switch(mOrthogonalSlicePlane) { case PLANE_X: slicePlaneNr = 0; width = input->getHeight(); height = input->getDepth(); spacing.x() = input->getSpacing().y(); spacing.y() = input->getSpacing().z(); break; case PLANE_Y: slicePlaneNr = 1; width = input->getWidth(); height = input->getDepth(); spacing.x() = input->getSpacing().x(); spacing.y() = input->getSpacing().z(); break; case PLANE_Z: slicePlaneNr = 2; width = input->getWidth(); height = input->getHeight(); spacing.x() = input->getSpacing().x(); spacing.y() = input->getSpacing().y(); break; } output->create(width, height, input->getDataType(), input->getNrOfComponents()); output->setSpacing(spacing); OpenCLImageAccess::pointer inputAccess = input->getOpenCLImageAccess(ACCESS_READ, device); OpenCLImageAccess::pointer outputAccess = output->getOpenCLImageAccess(ACCESS_READ_WRITE, device); cl::CommandQueue queue = device->getCommandQueue(); cl::Program program = getOpenCLProgram(device); cl::Kernel kernel(program, "orthogonalSlicing"); kernel.setArg(0, *inputAccess->get3DImage()); kernel.setArg(1, *outputAccess->get2DImage()); kernel.setArg(2, sliceNr); kernel.setArg(3, slicePlaneNr); queue.enqueueNDRangeKernel( kernel, cl::NullRange, cl::NDRange(width, height), cl::NullRange ); // TODO set scene graph transformation }