void SeededRegionGrowing::recompileOpenCLCode(Image::pointer input) { // Check if there is a need to recompile OpenCL code if(input->getDimensions() == mDimensionCLCodeCompiledFor && input->getDataType() == mTypeCLCodeCompiledFor) return; OpenCLDevice::pointer device = getMainDevice(); std::string buildOptions = ""; if(input->getDataType() == TYPE_FLOAT) { buildOptions = "-DTYPE_FLOAT"; } else if(input->getDataType() == TYPE_INT8 || input->getDataType() == TYPE_INT16) { buildOptions = "-DTYPE_INT"; } else { buildOptions = "-DTYPE_UINT"; } std::string filename; if(input->getDimensions() == 2) { filename = "Algorithms/SeededRegionGrowing/SeededRegionGrowing2D.cl"; } else { filename = "Algorithms/SeededRegionGrowing/SeededRegionGrowing3D.cl"; } int programNr = device->createProgramFromSource(std::string(FAST_SOURCE_DIR) + filename, buildOptions); mKernel = cl::Kernel(device->getProgram(programNr), "seededRegionGrowing"); mDimensionCLCodeCompiledFor = input->getDimensions(); mTypeCLCodeCompiledFor = input->getDataType(); }
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; recompile = false; OpenCLDevice::pointer device = getMainDevice(); std::string buildOptions = ""; if(!device->isWritingTo3DTexturesSupported()) { buildOptions = "-DTYPE=" + getCTypeAsString(mOutputType); } buildOptions += " -D WINDOW="; buildOptions += std::to_string((windowSize-1)/2); buildOptions += " -D GROUP="; buildOptions += std::to_string((groupSize-1)/2); buildOptions += " -D KVERSION="; buildOptions += std::to_string(k); buildOptions += " -D EUCLID="; buildOptions += std::to_string(k); cl::Program program; if(input->getDimensions() == 2) { program = getOpenCLProgram(device, "2D", buildOptions); } else { //createOpenCLProgram(std::string(FAST_SOURCE_DIR) + "Algorithms/NoneLocalMeans/NoneLocalMeans3Dgs.cl", "3D"); program = getOpenCLProgram(device, "3D", buildOptions); } mKernel = cl::Kernel(program, "noneLocalMeans"); mDimensionCLCodeCompiledFor = input->getDimensions(); mTypeCLCodeCompiledFor = input->getDataType(); }
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::waitToFinish() { if (!getMainDevice()->isHost()) { OpenCLDevice::pointer device = getMainDevice(); device->getCommandQueue().finish(); } }
/* 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 MeshRenderer::draw2D( cl::BufferGL PBO, uint width, uint height, Eigen::Transform<float, 3, Eigen::Affine> pixelToViewportTransform, float PBOspacing, Vector2f translation ) { boost::lock_guard<boost::mutex> lock(mMutex); OpenCLDevice::pointer device = getMainDevice(); cl::CommandQueue queue = device->getCommandQueue(); std::vector<cl::Memory> v; v.push_back(PBO); queue.enqueueAcquireGLObjects(&v); // Map would probably be better here, but doesn't work on NVIDIA, segfault surprise! //float* pixels = (float*)queue.enqueueMapBuffer(PBO, CL_TRUE, CL_MAP_WRITE, 0, width*height*sizeof(float)*4); boost::shared_array<float> pixels(new float[width*height*sizeof(float)*4]); queue.enqueueReadBuffer(PBO, CL_TRUE, 0, width*height*4*sizeof(float), pixels.get()); boost::unordered_map<uint, Mesh::pointer>::iterator it; for(it = mMeshToRender.begin(); it != mMeshToRender.end(); it++) { Mesh::pointer mesh = it->second; if(mesh->getDimensions() != 2) // Mesh must be 2D continue; Color color = mDefaultColor; ProcessObjectPort port = getInputPort(it->first); if(mInputColors.count(port) > 0) { color = mInputColors[port]; } MeshAccess::pointer access = mesh->getMeshAccess(ACCESS_READ); std::vector<VectorXui> lines = access->getLines(); std::vector<MeshVertex> vertices = access->getVertices(); // Draw each line for(int i = 0; i < lines.size(); ++i) { Vector2ui line = lines[i]; Vector2f a = vertices[line.x()].getPosition(); Vector2f b = vertices[line.y()].getPosition(); Vector2f direction = b - a; float lengthInPixels = ceil(direction.norm() / PBOspacing); // Draw the line for(int j = 0; j <= lengthInPixels; ++j) { Vector2f positionInMM = a + direction*((float)j/lengthInPixels); Vector2f positionInPixels = positionInMM / PBOspacing; int x = round(positionInPixels.x()); int y = round(positionInPixels.y()); y = height - 1 - y; if(x < 0 || y < 0 || x >= width || y >= height) continue; pixels[4*(x + y*width)] = color.getRedValue(); pixels[4*(x + y*width) + 1] = color.getGreenValue(); pixels[4*(x + y*width) + 2] = color.getBlueValue(); } } } //queue.enqueueUnmapMemObject(PBO, pixels); queue.enqueueWriteBuffer(PBO, CL_TRUE, 0, width*height*4*sizeof(float), pixels.get()); queue.enqueueReleaseGLObjects(&v); }
void BinaryThresholding::waitToFinish() { OpenCLDevice::pointer device = OpenCLDevice::pointer(getMainDevice()); device->getCommandQueue().finish(); }
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 NonLocalMeans::waitToFinish() { if (!getMainDevice()->isHost()) { OpenCLDevice::pointer device = std::dynamic_pointer_cast<OpenCLDevice>(getMainDevice()); device->getCommandQueue().finish(); } }
void getIntensitySumFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float* sum) { // Get power of two size unsigned int powerOfTwoSize = getPowerOfTwoSize(std::max(image.getImageInfo<CL_IMAGE_WIDTH>(), image.getImageInfo<CL_IMAGE_HEIGHT>())); // Create image levels unsigned int size = powerOfTwoSize; size /= 2; std::vector<cl::Image2D> levels; while(size >= 4) { cl::Image2D level = cl::Image2D(device->getContext(), CL_MEM_READ_WRITE, getOpenCLImageFormat(device, CL_MEM_OBJECT_IMAGE2D, TYPE_FLOAT, 1), size, size); levels.push_back(level); size /= 2; } // Compile OpenCL code std::string buildOptions = ""; switch(type) { case TYPE_FLOAT: buildOptions = "-DTYPE_FLOAT"; break; case TYPE_UINT8: buildOptions = "-DTYPE_UINT8"; break; case TYPE_INT8: buildOptions = "-DTYPE_INT8"; break; case TYPE_UINT16: buildOptions = "-DTYPE_UINT16"; break; case TYPE_INT16: buildOptions = "-DTYPE_INT16"; break; } std::string sourceFilename = std::string(FAST_SOURCE_DIR) + "/ImageSum.cl"; std::string programName = sourceFilename + buildOptions; // Only create program if it doesn't exist for this device from before if(!device->hasProgram(programName)) device->createProgramFromSourceWithName(programName, sourceFilename, buildOptions); cl::Program program = device->getProgram(programName); cl::CommandQueue queue = device->getCommandQueue(); // Fill first level size = powerOfTwoSize/2; cl::Kernel firstLevel(program, "createFirstSumImage2DLevel"); firstLevel.setArg(0, image); firstLevel.setArg(1, levels[0]); queue.enqueueNDRangeKernel( firstLevel, cl::NullRange, cl::NDRange(size,size), cl::NullRange ); // Fill all other levels cl::Kernel createLevel(program, "createSumImage2DLevel"); int i = 0; size /= 2; while(size >= 4) { createLevel.setArg(0, levels[i]); createLevel.setArg(1, levels[i+1]); queue.enqueueNDRangeKernel( createLevel, cl::NullRange, cl::NDRange(size,size), cl::NullRange ); i++; size /= 2; } // Get result from the last level unsigned int nrOfElements = 4*4; unsigned int nrOfComponents = getOpenCLImageFormat(device, CL_MEM_OBJECT_IMAGE2D, TYPE_FLOAT, 1).image_channel_order == CL_RGBA ? 4 : 1; float* result = (float*)allocateDataArray(nrOfElements,TYPE_FLOAT,nrOfComponents); queue.enqueueReadImage(levels[levels.size()-1],CL_TRUE,createOrigoRegion(),createRegion(4,4,1),0,0,result); *sum = getSumFromOpenCLImageResult<float>(result, nrOfElements, nrOfComponents); delete[] result; }
void getMaxAndMinFromOpenCLBuffer(OpenCLDevice::pointer device, cl::Buffer buffer, unsigned int size, DataType type, float* min, float* max) { // Compile OpenCL code std::string buildOptions = ""; switch(type) { case TYPE_FLOAT: buildOptions = "-DTYPE_FLOAT"; break; case TYPE_UINT8: buildOptions = "-DTYPE_UINT8"; break; case TYPE_INT8: buildOptions = "-DTYPE_INT8"; break; case TYPE_UINT16: buildOptions = "-DTYPE_UINT16"; break; case TYPE_INT16: buildOptions = "-DTYPE_INT16"; break; } std::string sourceFilename = std::string(FAST_SOURCE_DIR) + "/ImageMinMax.cl"; std::string programName = sourceFilename + buildOptions; // Only create program if it doesn't exist for this device from before if(!device->hasProgram(programName)) device->createProgramFromSourceWithName(programName, sourceFilename, buildOptions); cl::Program program = device->getProgram(programName); cl::CommandQueue queue = device->getCommandQueue(); // Nr of work groups must be set so that work-group size does not exceed max work-group size (256 on AMD) int length = size; cl::Kernel reduce(program, "reduce"); cl::Buffer current = buffer; cl::Buffer clResult; int workGroupSize = 256; int workGroups = 256; int X = ceil((float)length / (workGroups*workGroupSize)); clResult = cl::Buffer(device->getContext(), CL_MEM_READ_WRITE, getSizeOfDataType(type,1)*workGroups*2); reduce.setArg(0, current); reduce.setArg(1, workGroupSize * getSizeOfDataType(type,1), NULL); reduce.setArg(2, workGroupSize * getSizeOfDataType(type,1), NULL); reduce.setArg(3, size); reduce.setArg(4, X); reduce.setArg(5, clResult); queue.enqueueNDRangeKernel( reduce, cl::NullRange, cl::NDRange(workGroups*workGroupSize), cl::NDRange(workGroupSize) ); length = workGroups; void* result = allocateDataArray(length, type, 2); unsigned int nrOfElements = length; queue.enqueueReadBuffer(clResult,CL_TRUE,0,getSizeOfDataType(type,1)*workGroups*2,result); switch(type) { case TYPE_FLOAT: getMaxAndMinFromOpenCLImageResult<float>(result, nrOfElements, 2, min, max); break; case TYPE_INT8: getMaxAndMinFromOpenCLImageResult<char>(result, nrOfElements, 2, min, max); break; case TYPE_UINT8: getMaxAndMinFromOpenCLImageResult<uchar>(result, nrOfElements, 2, min, max); break; case TYPE_INT16: getMaxAndMinFromOpenCLImageResult<short>(result, nrOfElements, 2, min, max); break; case TYPE_UINT16: getMaxAndMinFromOpenCLImageResult<ushort>(result, nrOfElements, 2, min, max); break; } deleteArray(result, type); }
void SeededRegionGrowing::waitToFinish() { if(!getMainDevice()->isHost()) { OpenCLDevice::pointer device = getMainDevice(); device->getCommandQueue().finish(); } }
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 }
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); }