FastMKSRules<KernelType, TreeType>::FastMKSRules(const arma::mat& referenceSet,
const arma::mat& querySet,
arma::Mat<size_t>& indices,
arma::mat& products,
KernelType& kernel) :
referenceSet(referenceSet),
querySet(querySet),
indices(indices),
products(products),
kernel(kernel),
lastQueryIndex(-1),
lastReferenceIndex(-1),
lastKernel(0.0),
baseCases(0),
scores(0)
{
// Precompute each self-kernel.
queryKernels.set_size(querySet.n_cols);
for (size_t i = 0; i < querySet.n_cols; ++i)
queryKernels[i] = sqrt(kernel.Evaluate(querySet.unsafe_col(i),
querySet.unsafe_col(i)));
referenceKernels.set_size(referenceSet.n_cols);
for (size_t i = 0; i < referenceSet.n_cols; ++i)
referenceKernels[i] = sqrt(kernel.Evaluate(referenceSet.unsafe_col(i),
referenceSet.unsafe_col(i)));
// Set to invalid memory, so that the first node combination does not try to
// dereference null pointers.
traversalInfo.LastQueryNode() = (TreeType*) this;
traversalInfo.LastReferenceNode() = (TreeType*) this;
}
EnableForValid<parameterIndex> configureParameters(
const cl::Context& context, KernelType& kernel,
unsigned int startingIndex) {
const auto nextParameterIndex = parameterIndex + 1;
auto parameterValue = getParameter<parameterIndex>(context);
kernel.setArg(startingIndex + parameterIndex, parameterValue);
configureParameters<nextParameterIndex>(context, kernel, startingIndex);
}
/**
* Construct the exact kernel matrix.
*
* @param data Input data points.
* @param transformedData Matrix to output results into.
* @param eigval KPCA eigenvalues will be written to this vector.
* @param eigvec KPCA eigenvectors will be written to this matrix.
* @param rank Rank to be used for matrix approximation.
* @param kernel Kernel to be used for computation.
*/
static void ApplyKernelMatrix(const arma::mat& data,
arma::mat& transformedData,
arma::vec& eigval,
arma::mat& eigvec,
const size_t /* unused */,
KernelType kernel = KernelType())
{
// Construct the kernel matrix.
arma::mat kernelMatrix;
// Resize the kernel matrix to the right size.
kernelMatrix.set_size(data.n_cols, data.n_cols);
// Note that we only need to calculate the upper triangular part of the
// kernel matrix, since it is symmetric. This helps minimize the number of
// kernel evaluations.
for (size_t i = 0; i < data.n_cols; ++i)
{
for (size_t j = i; j < data.n_cols; ++j)
{
// Evaluate the kernel on these two points.
kernelMatrix(i, j) = kernel.Evaluate(data.unsafe_col(i),
data.unsafe_col(j));
}
}
// Copy to the lower triangular part of the matrix.
for (size_t i = 1; i < data.n_cols; ++i)
for (size_t j = 0; j < i; ++j)
kernelMatrix(i, j) = kernelMatrix(j, i);
// For PCA the data has to be centered, even if the data is centered. But it
// is not guaranteed that the data, when mapped to the kernel space, is also
// centered. Since we actually never work in the feature space we cannot
// center the data. So, we perform a "psuedo-centering" using the kernel
// matrix.
arma::rowvec rowMean = arma::sum(kernelMatrix, 0) / kernelMatrix.n_cols;
kernelMatrix.each_col() -= arma::sum(kernelMatrix, 1) / kernelMatrix.n_cols;
kernelMatrix.each_row() -= rowMean;
kernelMatrix += arma::sum(rowMean) / kernelMatrix.n_cols;
// Eigendecompose the centered kernel matrix.
arma::eig_sym(eigval, eigvec, kernelMatrix);
// Swap the eigenvalues since they are ordered backwards (we need largest to
// smallest).
for (size_t i = 0; i < floor(eigval.n_elem / 2.0); ++i)
eigval.swap_rows(i, (eigval.n_elem - 1) - i);
// Flip the coefficients to produce the same effect.
eigvec = arma::fliplr(eigvec);
transformedData = eigvec.t() * kernelMatrix;
transformedData.each_col() /= arma::sqrt(eigval);
}
medAbstractJob::medJobExitStatus medItkErodeImageProcess::_run()
{
typedef itk::Image<inputType, 3> ImageType;
typename ImageType::Pointer in = dynamic_cast<ImageType *>((itk::Object*)(this->input()->data()));
if(in.IsNotNull())
{
typedef itk::BinaryBallStructuringElement<inputType, 3> KernelType;
typedef itk::GrayscaleErodeImageFilter<ImageType, ImageType, KernelType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
m_filter = filter;
KernelType kernel;
kernel.SetRadius(this->kernelRadius()->value());
kernel.CreateStructuringElement();
filter->SetKernel(kernel);
filter->SetInput(in);
itk::CStyleCommand::Pointer callback = itk::CStyleCommand::New();
callback->SetClientData((void*)this);
callback->SetCallback(medItkErodeImageProcess::eventCallback);
filter->AddObserver(itk::ProgressEvent(), callback);
try
{
filter->Update();
}
catch(itk::ProcessAborted &e)
{
return medAbstractJob::MED_JOB_EXIT_CANCELLED;
}
medAbstractImageData *out= dynamic_cast<medAbstractImageData *>(medAbstractDataFactory::instance()->create(this->input()->identifier()));
out->setData(filter->GetOutput());
this->setOutput(out);
return medAbstractJob::MED_JOB_EXIT_SUCCESS;
}
return medAbstractJob::MED_JOB_EXIT_FAILURE;
}
void enqueue(KernelType & k, viennacl::ocl::command_queue const & queue)
{
// 1D kernel:
if (k.local_work_size(1) == 0)
{
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
std::cout << "ViennaCL: Starting 1D-kernel '" << k.name() << "'..." << std::endl;
std::cout << "ViennaCL: Global work size: '" << k.global_work_size() << "'..." << std::endl;
std::cout << "ViennaCL: Local work size: '" << k.local_work_size() << "'..." << std::endl;
#endif
size_t tmp_global = k.global_work_size();
size_t tmp_local = k.local_work_size();
cl_int err;
if (tmp_global == 1 && tmp_local == 1)
err = clEnqueueTask(queue.handle().get(), k.handle().get(), 0, NULL, NULL);
else
err = clEnqueueNDRangeKernel(queue.handle().get(), k.handle().get(), 1, NULL, &tmp_global, &tmp_local, 0, NULL, NULL);
if (err != CL_SUCCESS) //if not successful, try to start with smaller work size
{
//std::cout << "FAIL: " << std::endl; exit(0);
while (err != CL_SUCCESS && tmp_local > 1)
{
//std::cout << "Flushing queue, then enqueuing again with half the size..." << std::endl;
//std::cout << "Error code: " << err << std::endl;
tmp_global /= 2;
tmp_local /= 2;
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
std::cout << "ViennaCL: Kernel start failed for '" << k.name() << "'." << std::endl;
std::cout << "ViennaCL: Global work size: '" << tmp_global << "'..." << std::endl;
std::cout << "ViennaCL: Local work size: '" << tmp_local << "'..." << std::endl;
#endif
queue.finish();
err = clEnqueueNDRangeKernel(queue.handle().get(), k.handle().get(), 1, NULL, &tmp_global, &tmp_local, 0, NULL, NULL);
}
if (err != CL_SUCCESS)
{
//could not start kernel with any parameters
std::cerr << "ViennaCL: FATAL ERROR: Kernel start failed for '" << k.name() << "'." << std::endl;
std::cerr << "ViennaCL: Smaller work sizes could not solve the problem. " << std::endl;
VIENNACL_ERR_CHECK(err);
}
else
{
//remember parameters:
k.local_work_size(0, tmp_local);
k.global_work_size(0, tmp_global);
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
std::cout << "ViennaCL: Kernel '" << k.name() << "' now uses global work size " << tmp_global << " and local work size " << tmp_local << "." << std::endl;
#endif
}
}
}
else //2D kernel
{
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
std::cout << "ViennaCL: Starting 2D-kernel '" << k.name() << "'..." << std::endl;
std::cout << "ViennaCL: Global work size: '" << k.global_work_size(0) << ", " << k.global_work_size(1) << "'..." << std::endl;
std::cout << "ViennaCL: Local work size: '" << k.local_work_size(0) << ", " << k.local_work_size(1) << "'..." << std::endl;
#endif
size_t tmp_global[2];
tmp_global[0] = k.global_work_size(0);
tmp_global[1] = k.global_work_size(1);
size_t tmp_local[2];
tmp_local[0] = k.local_work_size(0);
tmp_local[1] = k.local_work_size(1);
cl_int err = clEnqueueNDRangeKernel(queue.handle().get(), k.handle().get(), 2, NULL, tmp_global, tmp_local, 0, NULL, NULL);
if (err != CL_SUCCESS)
{
//could not start kernel with any parameters
std::cerr << "ViennaCL: FATAL ERROR: Kernel start failed for '" << k.name() << "'." << std::endl;
VIENNACL_ERR_CHECK(err);
}
}
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
queue.finish();
std::cout << "ViennaCL: Kernel " << k.name() << " finished!" << std::endl;
#endif
} //enqueue()
void DilateObjectMorphologyImageFilterITK::dilateObjectMorphologyImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typedef T PixelType;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
if(structuringElement_.get() == "binaryBall"){
shape_.setVisible(false);
typedef itk::BinaryBallStructuringElement < PixelType, 3 > KernelType;
typedef itk::DilateObjectMorphologyImageFilter<InputImageType1, OutputImageType1, KernelType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
KernelType structuringElement;
typename KernelType::SizeType radius;
radius[0] = radius_.get().x;
radius[1] = radius_.get().y;
radius[2] = radius_.get().z;
structuringElement.SetRadius(radius);
structuringElement.CreateStructuringElement();
filter->SetKernel(structuringElement);
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
else if(structuringElement_.get() == "binaryCross"){
shape_.setVisible(false);
typedef itk::BinaryCrossStructuringElement < PixelType, 3 > KernelType;
typedef itk::DilateObjectMorphologyImageFilter<InputImageType1, OutputImageType1, KernelType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
KernelType structuringElement;
typename KernelType::SizeType radius;
radius[0] = radius_.get().x;
radius[1] = radius_.get().y;
radius[2] = radius_.get().z;
structuringElement.SetRadius(radius);
structuringElement.CreateStructuringElement();
filter->SetKernel(structuringElement);
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
else if(structuringElement_.get() == "flat"){
shape_.setVisible(true);
typedef itk::FlatStructuringElement < 3 > KernelType;
typename KernelType::SizeType radius;
radius[0] = radius_.get().x;
radius[1] = radius_.get().y;
radius[2] = radius_.get().z;
if(shape_.get() == "box"){
KernelType structuringElement = KernelType::Box(radius);
typedef itk::DilateObjectMorphologyImageFilter<InputImageType1, OutputImageType1, KernelType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetKernel(structuringElement);
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
else if(shape_.get() == "ball"){
KernelType structuringElement = KernelType::Ball(radius);
typedef itk::DilateObjectMorphologyImageFilter<InputImageType1, OutputImageType1, KernelType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetKernel(structuringElement);
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
else if(shape_.get() == "cross"){
KernelType structuringElement = KernelType::Cross(radius);
typedef itk::DilateObjectMorphologyImageFilter<InputImageType1, OutputImageType1, KernelType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetKernel(structuringElement);
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
else if(shape_.get() == "annulus"){
KernelType structuringElement = KernelType::Annulus(radius);
typedef itk::DilateObjectMorphologyImageFilter<InputImageType1, OutputImageType1, KernelType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetKernel(structuringElement);
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
}
}
void enqueue(KernelType & k)
{
enqueue(k, k.context().get_queue());
}
void enqueue(KernelType & k, viennacl::ocl::command_queue const & queue)
{
// 1D kernel:
if (k.local_work_size(1) == 0)
{
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
std::cout << "ViennaCL: Starting 1D-kernel '" << k.name() << "'..." << std::endl;
std::cout << "ViennaCL: Global work size: '" << k.global_work_size() << "'..." << std::endl;
std::cout << "ViennaCL: Local work size: '" << k.local_work_size() << "'..." << std::endl;
#endif
vcl_size_t tmp_global = k.global_work_size();
vcl_size_t tmp_local = k.local_work_size();
cl_int err;
if (tmp_global == 1 && tmp_local == 1)
err = clEnqueueTask(queue.handle().get(), k.handle().get(), 0, NULL, NULL);
else
err = clEnqueueNDRangeKernel(queue.handle().get(), k.handle().get(), 1, NULL, &tmp_global, &tmp_local, 0, NULL, NULL);
if (err != CL_SUCCESS)
{
std::cerr << "ViennaCL: FATAL ERROR: Kernel start failed for '" << k.name() << "'." << std::endl;
std::cerr << "ViennaCL: Smaller work sizes could not solve the problem. " << std::endl;
VIENNACL_ERR_CHECK(err);
}
}
else //2D or 3D kernel
{
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
std::cout << "ViennaCL: Starting 2D/3D-kernel '" << k.name() << "'..." << std::endl;
std::cout << "ViennaCL: Global work size: '" << k.global_work_size(0) << ", " << k.global_work_size(1) << ", " << k.global_work_size(2) << "'..." << std::endl;
std::cout << "ViennaCL: Local work size: '" << k.local_work_size(0) << ", " << k.local_work_size(1) << ", " << k.local_work_size(2) << "'..." << std::endl;
#endif
vcl_size_t tmp_global[3];
tmp_global[0] = k.global_work_size(0);
tmp_global[1] = k.global_work_size(1);
tmp_global[2] = k.global_work_size(2);
vcl_size_t tmp_local[3];
tmp_local[0] = k.local_work_size(0);
tmp_local[1] = k.local_work_size(1);
tmp_local[2] = k.local_work_size(2);
cl_int err = clEnqueueNDRangeKernel(queue.handle().get(), k.handle().get(), (tmp_global[2] == 0) ? 2 : 3, NULL, tmp_global, tmp_local, 0, NULL, NULL);
if (err != CL_SUCCESS)
{
//could not start kernel with any parameters
std::cerr << "ViennaCL: FATAL ERROR: Kernel start failed for '" << k.name() << "'." << std::endl;
VIENNACL_ERR_CHECK(err);
}
}
#if defined(VIENNACL_DEBUG_ALL) || defined(VIENNACL_DEBUG_KERNEL)
queue.finish();
std::cout << "ViennaCL: Kernel " << k.name() << " finished!" << std::endl;
#endif
} //enqueue()
//重构操作
void segmentation::on_morphologyOperationButton_clicked()
{
const int dimension = 3;
typedef itk::Image< unsigned char, dimension > IType;
typedef itk::ImageFileReader< IType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
IType::Pointer inputImage = IType::New();
reader->SetFileName( initFileName );//读入二值图
reader->Update();
inputImage = reader->GetOutput();
IType::SizeType imgSize;
IType::IndexType voxelIndex;
imgSize = inputImage->GetLargestPossibleRegion().GetSize();
typedef itk::BinaryBallStructuringElement< bool, dimension> KernelType;
KernelType ball;
KernelType::SizeType ballSize;
ofstream fout;
long vol = 0;
unsigned char temp;
float r;
for(int z = 0; z < imgSize[2]; z++)
for(int y = 0; y < imgSize[1]; y++)
for(int x = 0; x < imgSize[0]; x++)
{
voxelIndex[0] = x;
voxelIndex[1] = y;
voxelIndex[2] = z;
temp = inputImage->GetPixel(voxelIndex);
if(temp == 255)
vol += 1;
}
r = pow((3 * vol) / (4 * PI), (1.0 / 3)) ;
r = r / 6;//experiment data
ballSize.Fill( r );//radius
ball.SetRadius(ballSize);
ball.CreateStructuringElement();
typedef itk::BinaryOpeningByReconstructionImageFilter< IType, KernelType > I2LType;
I2LType::Pointer reconstruction = I2LType::New();
reconstruction->SetInput( reader->GetOutput() );
reconstruction->SetKernel( ball );
reconstruction->SetFullyConnected( 1 );
reconstruction->SetForegroundValue( 255 );
itk::SimpleFilterWatcher watcher(reconstruction, "filter");
//文件前缀名
filePrefix = inputFileName;//char* to string
filePrefix = filePrefix.substr(0, filePrefix.length() - 4);
string morphologyFileName;
morphologyFileName = filePrefix + "_morphologyResult.mhd";
strcpy(outputFileName, morphologyFileName.c_str());//string to char*
typedef itk::ImageFileWriter< IType > WriterType;
WriterType::Pointer morphologyWriter = WriterType::New();
morphologyWriter->SetInput( reconstruction->GetOutput() );
morphologyWriter->SetFileName( outputFileName );
morphologyWriter->Update();
//腐蚀结果叠加到原图
typedef itk::Image< unsigned short, dimension > OriginalImageType;
typedef itk::ImageFileReader<OriginalImageType>OriginalReaderType;
OriginalReaderType::Pointer orignalImgreader = OriginalReaderType::New();
OriginalImageType::Pointer originalImage = OriginalImageType::New();
OriginalReaderType::IndexType originalImgVoxelIndex;
reader->SetFileName(outputFileName);//读入重构操作结果图像
reader->Update();
inputImage = reader->GetOutput();
orignalImgreader->SetFileName(inputFileName);//读入原图像
orignalImgreader->Update();
originalImage = orignalImgreader->GetOutput();
for(int z = 0; z < imgSize[2]; z++)
for(int y = 0; y < imgSize[1]; y++)
for(int x = 0; x < imgSize[0]; x++)
{
voxelIndex[0] = x;
voxelIndex[1] = y;
voxelIndex[2] = z;
originalImgVoxelIndex[0] = x;
originalImgVoxelIndex[1] = y;
originalImgVoxelIndex[2] = z;
temp = inputImage->GetPixel(voxelIndex);
if(temp == 255)
originalImage->SetPixel(originalImgVoxelIndex, 65535);
}
//输出结果
typedef itk::ImageFileWriter<OriginalImageType>NewWriterType;
NewWriterType::Pointer writer = NewWriterType::New();
//文件前缀名
filePrefix = inputFileName;//char* to string
filePrefix = filePrefix.substr(0, filePrefix.length() - 4);
filePrefix = filePrefix + "_refinedResult.mhd";
strcpy(outputFileName, filePrefix.c_str());//string to char*
writer->SetFileName(outputFileName);
writer->SetInput(originalImage);
writer->Update();
emit returnInternalFileName(initResultFileName);//更新原视图
emit returnOutputFileName(outputFileName);//显示结果图
}
