void BinaryThresholding::execute() { if(!mLowerThresholdSet && !mUpperThresholdSet) { throw Exception("BinaryThresholding need at least one threshold to be set."); } Image::pointer input = getStaticInputData<Image>(0); Segmentation::pointer output = getStaticOutputData<Segmentation>(0); output->createFromImage(input); if(getMainDevice()->isHost()) { throw Exception("Not implemented yet."); } else { OpenCLDevice::pointer device = OpenCLDevice::pointer(getMainDevice()); cl::Program program; if(input->getDimensions() == 3) { program = getOpenCLProgram(device, "3D"); } else { program = getOpenCLProgram(device, "2D"); } cl::Kernel kernel; if(mLowerThresholdSet && mUpperThresholdSet) { kernel = cl::Kernel(program, "tresholding"); kernel.setArg(3, mLowerThreshold); kernel.setArg(4, mUpperThreshold); } else if(mLowerThresholdSet) { kernel = cl::Kernel(program, "thresholdingWithOnlyLower"); kernel.setArg(3, mLowerThreshold); } else { kernel = cl::Kernel(program, "thresholdingWithOnlyUpper"); kernel.setArg(3, mUpperThreshold); } cl::NDRange globalSize; OpenCLImageAccess::pointer access = input->getOpenCLImageAccess(ACCESS_READ, device); if(input->getDimensions() == 2) { OpenCLImageAccess::pointer access2 = output->getOpenCLImageAccess(ACCESS_READ_WRITE, device); kernel.setArg(0, *access->get2DImage()); kernel.setArg(1, *access2->get2DImage()); globalSize = cl::NDRange(output->getWidth(), output->getHeight()); } else { // TODO no 3d image write support OpenCLImageAccess::pointer access2 = output->getOpenCLImageAccess(ACCESS_READ_WRITE, device); kernel.setArg(0, *access->get3DImage()); kernel.setArg(1, *access2->get3DImage()); globalSize = cl::NDRange(output->getWidth(), output->getHeight(), output->getDepth()); } kernel.setArg(2, (uchar)mLabel); cl::CommandQueue queue = device->getCommandQueue(); queue.enqueueNDRangeKernel( kernel, cl::NullRange, globalSize, cl::NullRange ); } }
void Dilation::execute() { Image::pointer input = getInputData<Image>(); if(input->getDataType() != TYPE_UINT8) { throw Exception("Data type of image given to Dilation must be UINT8"); } Image::pointer output = getOutputData<Image>(); output->createFromImage(input); SceneGraph::setParentNode(output, input); output->fill(0); OpenCLDevice::pointer device = std::dynamic_pointer_cast<OpenCLDevice>(getMainDevice()); cl::CommandQueue queue = device->getCommandQueue(); cl::Program program = getOpenCLProgram(device); cl::Kernel dilateKernel(program, "dilate"); Vector3ui size = input->getSize(); OpenCLImageAccess::pointer access = input->getOpenCLImageAccess(ACCESS_READ, device); dilateKernel.setArg(0, *access->get3DImage()); dilateKernel.setArg(2, mSize/2); if(!device->isWritingTo3DTexturesSupported()) { OpenCLBufferAccess::pointer access2 = output->getOpenCLBufferAccess(ACCESS_READ_WRITE, device); dilateKernel.setArg(1, *access2->get()); queue.enqueueNDRangeKernel( dilateKernel, cl::NullRange, cl::NDRange(size.x(), size.y(), size.z()), cl::NullRange ); } else { OpenCLImageAccess::pointer access2 = output->getOpenCLImageAccess(ACCESS_READ_WRITE, device); dilateKernel.setArg(1, *access2->get3DImage()); queue.enqueueNDRangeKernel( dilateKernel, cl::NullRange, cl::NDRange(size.x(), size.y(), size.z()), cl::NullRange ); } }
/* 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 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 }
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); 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; OpenCLImageAccess::pointer inputAccess = input->getOpenCLImageAccess(ACCESS_READ, device); if(output->getDimensions() == 2) { globalSize = cl::NDRange(input->getWidth(),input->getHeight()); mKernel.setArg(0, *inputAccess->get2DImage()); } else { globalSize = cl::NDRange(input->getWidth(),input->getHeight(), input->getDepth()); mKernel.setArg(0, *inputAccess->get3DImage()); } 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 SegmentationRenderer::draw(Matrix4f perspectiveMatrix, Matrix4f viewingMatrix, float zNear, float zFar, bool mode2D) { std::lock_guard<std::mutex> lock(mMutex); OpenCLDevice::pointer device = std::dynamic_pointer_cast<OpenCLDevice>(getMainDevice()); if(mColorsModified) { // Transfer colors to device (this doesn't have to happen every render call..) std::unique_ptr<float[]> colorData(new float[3*mLabelColors.size()]); std::unordered_map<int, Color>::iterator it; for(it = mLabelColors.begin(); it != mLabelColors.end(); it++) { colorData[it->first*3] = it->second.getRedValue(); colorData[it->first*3+1] = it->second.getGreenValue(); colorData[it->first*3+2] = it->second.getBlueValue(); } mColorBuffer = cl::Buffer( device->getContext(), CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float)*3*mLabelColors.size(), colorData.get() ); } if(mFillAreaModified) { // Transfer colors to device (this doesn't have to happen every render call..) std::unique_ptr<char[]> fillAreaData(new char[mLabelColors.size()]); std::unordered_map<int, Color>::iterator it; for(it = mLabelColors.begin(); it != mLabelColors.end(); it++) { if(mLabelFillArea.count(it->first) == 0) { // Use default value fillAreaData[it->first] = mFillArea; } else { fillAreaData[it->first] = mLabelFillArea[it->first]; } } mFillAreaBuffer = cl::Buffer( device->getContext(), CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(char)*mLabelColors.size(), fillAreaData.get() ); } mKernel = cl::Kernel(getOpenCLProgram(device), "renderToTexture"); mKernel.setArg(2, mColorBuffer); mKernel.setArg(3, mFillAreaBuffer); mKernel.setArg(4, mBorderRadius); mKernel.setArg(5, mOpacity); for(auto it : mDataToRender) { Image::pointer input = std::static_pointer_cast<Image>(it.second); uint inputNr = it.first; if(input->getDimensions() != 2) throw Exception("SegmentationRenderer only supports 2D images. Use ImageSlicer to extract a 2D slice from a 3D image."); if(input->getDataType() != TYPE_UINT8) throw Exception("SegmentationRenderer only support images with dat type uint8."); // Check if a texture has already been created for this image if(mTexturesToRender.count(inputNr) > 0 && mImageUsed[inputNr] == input) continue; // If it has already been created, skip it // If it has not been created, create the texture OpenCLImageAccess::pointer access = input->getOpenCLImageAccess(ACCESS_READ, device); cl::Image2D *clImage = access->get2DImage(); // Run kernel to fill the texture cl::CommandQueue queue = device->getCommandQueue(); if (mTexturesToRender.count(inputNr) > 0) { // Delete old texture glDeleteTextures(1, &mTexturesToRender[inputNr]); mTexturesToRender.erase(inputNr); glDeleteVertexArrays(1, &mVAO[inputNr]); mVAO.erase(inputNr); } cl::Image2D image; cl::ImageGL imageGL; std::vector<cl::Memory> v; GLuint textureID; // TODO The GL-CL interop here is causing glClear to not work on AMD systems and therefore disabled /* if(DeviceManager::isGLInteropEnabled()) { // Create OpenGL texture glGenTextures(1, &textureID); glBindTexture(GL_TEXTURE_2D, textureID); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, input->getWidth(), input->getHeight(), 0, GL_RGBA, GL_FLOAT, 0); // Create CL-GL image imageGL = cl::ImageGL( device->getContext(), CL_MEM_READ_WRITE, GL_TEXTURE_2D, 0, textureID ); glBindTexture(GL_TEXTURE_2D, 0); glFinish(); mKernel.setArg(1, imageGL); v.push_back(imageGL); queue.enqueueAcquireGLObjects(&v); } else { */ image = cl::Image2D( device->getContext(), CL_MEM_READ_WRITE, cl::ImageFormat(CL_RGBA, CL_FLOAT), input->getWidth(), input->getHeight() ); mKernel.setArg(1, image); //} mKernel.setArg(0, *clImage); queue.enqueueNDRangeKernel( mKernel, cl::NullRange, cl::NDRange(input->getWidth(), input->getHeight()), cl::NullRange ); /*if(DeviceManager::isGLInteropEnabled()) { queue.enqueueReleaseGLObjects(&v); } else {*/ // Copy data from CL image to CPU auto data = make_uninitialized_unique<float[]>(input->getWidth() * input->getHeight() * 4); queue.enqueueReadImage( image, CL_TRUE, createOrigoRegion(), createRegion(input->getWidth(), input->getHeight(), 1), 0, 0, data.get() ); // Copy data from CPU to GL texture glGenTextures(1, &textureID); glBindTexture(GL_TEXTURE_2D, textureID); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, input->getWidth(), input->getHeight(), 0, GL_RGBA, GL_FLOAT, data.get()); glBindTexture(GL_TEXTURE_2D, 0); glFinish(); //} mTexturesToRender[inputNr] = textureID; mImageUsed[inputNr] = input; queue.finish(); } glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); drawTextures(perspectiveMatrix, viewingMatrix, mode2D); glDisable(GL_BLEND); }