static igtl::ImageMessage::Pointer createIGTLImageMessage(Image::pointer image) {
// size parameters
int size[3] = {(int)image->getWidth(), (int)image->getHeight(), (int)image->getDepth()}; // image dimension
float spacing[3] = {image->getSpacing().x(), image->getSpacing().y(), image->getSpacing().z()}; // spacing (mm/pixel)
int svoffset[3] = {0, 0, 0}; // sub-volume offset
int scalarType;
size_t totalSize = image->getWidth()*image->getHeight()*image->getDepth()*image->getNrOfChannels();
switch(image->getDataType()) {
case TYPE_UINT8:
scalarType = igtl::ImageMessage::TYPE_UINT8;
totalSize *= sizeof(unsigned char);
break;
case TYPE_INT8:
scalarType = igtl::ImageMessage::TYPE_INT8;
totalSize *= sizeof(char);
break;
case TYPE_UINT16:
scalarType = igtl::ImageMessage::TYPE_UINT16;
totalSize *= sizeof(unsigned short);
break;
case TYPE_INT16:
scalarType = igtl::ImageMessage::TYPE_INT16;
totalSize *= sizeof(short);
break;
case TYPE_FLOAT:
scalarType = igtl::ImageMessage::TYPE_FLOAT32;
totalSize *= sizeof(float);
break;
}
//------------------------------------------------------------
// Create a new IMAGE type message
igtl::ImageMessage::Pointer imgMsg = igtl::ImageMessage::New();
imgMsg->SetDimensions(size);
imgMsg->SetSpacing(spacing);
imgMsg->SetNumComponents(image->getNrOfChannels());
imgMsg->SetScalarType(scalarType);
imgMsg->SetDeviceName("DummyImage");
imgMsg->SetSubVolume(size, svoffset);
imgMsg->AllocateScalars();
ImageAccess::pointer access = image->getImageAccess(ACCESS_READ);
memcpy(imgMsg->GetScalarPointer(), access->get(), totalSize);
return imgMsg;
}
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::executeOnHost(T* input, Image::pointer output) {
ImageAccess::pointer outputAccess = output->getImageAccess(ACCESS_READ_WRITE);
uchar* outputData = (uchar*)outputAccess->get();
// initialize output to all zero
memset(outputData, 0, output->getWidth()*output->getHeight()*output->getDepth());
std::stack<Vector3ui> queue;
// Add seeds to queue
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.");
queue.push(pos);
}
// Process queue
while(!queue.empty()) {
Vector3ui pos = queue.top();
queue.pop();
// Add neighbors to queue
for(int a = -1; a < 2; a++) {
for(int b = -1; b < 2; b++) {
for(int c = -1; c < 2; c++) {
if(abs(a)+abs(b)+abs(c) != 1) // connectivity
continue;
Vector3ui neighbor(pos.x()+a,pos.y()+b,pos.z()+c);
// Check for out of bounds
if(neighbor.x() < 0 || neighbor.y() < 0 || neighbor.z() < 0 ||
neighbor.x() >= output->getWidth() || neighbor.y() >= output->getHeight() || neighbor.z() >= output->getDepth())
continue;
// Check that voxel is not already segmented
if(outputData[neighbor.x()+neighbor.y()*output->getWidth()+neighbor.z()*output->getWidth()*output->getHeight()] == 1)
continue;
// Check condition
T value = input[neighbor.x()+neighbor.y()*output->getWidth()+neighbor.z()*output->getWidth()*output->getHeight()];
if(value >= mMinimumIntensity && value <= mMaximumIntensity) {
// add it to segmentation
outputData[neighbor.x()+neighbor.y()*output->getWidth()+neighbor.z()*output->getWidth()*output->getHeight()] = 1;
// Add to queue
queue.push(neighbor);
}
}}}
}
}
/*
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 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
}
#include "VTKImageImporter.hpp"
#include "VTKImageExporter.hpp"
#include "ImageImporter.hpp"
using namespace fast;
// TODO rewrite this test so that it doesn't use the vtk exporter
TEST_CASE("Import an image from VTK to FAST", "[fast][VTK]") {
ImageImporter::pointer importer = ImageImporter::New();
importer->setFilename(std::string(FAST_TEST_DATA_DIR) + "US-2D.jpg");
Image::pointer fastImage = importer->getOutput();
// VTK Export
vtkSmartPointer<VTKImageExporter> vtkExporter = VTKImageExporter::New();
vtkExporter->SetInput(fastImage);
vtkSmartPointer<vtkImageData> vtkImage = vtkExporter->GetOutput();
vtkExporter->Update();
// VTK Import example
VTKImageImporter::pointer vtkImporter = VTKImageImporter::New();
vtkImporter->setInput(vtkImage);
Image::pointer importedImage = vtkImporter->getOutput();
vtkImporter->update();
CHECK(fastImage->getWidth() == importedImage->getWidth());
CHECK(fastImage->getHeight() == importedImage->getHeight());
CHECK(fastImage->getDepth() == 1);
CHECK(fastImage->getDimensions() == 2);
CHECK(fastImage->getDataType() == TYPE_FLOAT);
}