//Typedefs
typedef typename OutputImageType::PixelType PixelType;
typedef itk::Image<double, ImageDimension > WeightsImageType;
- typedef itk::Image<itk::SimpleFastMutexLock, ImageDimension > MutexImageType;
+#if ITK_VERSION_MAJOR <= 4
+ typedef itk::Image<itk::SimpleFastMutexLock, ImageDimension> MutexImageType;
+#endif
//===================================================================================
//Set methods
m_Weights = input;
this->Modified();
}
+#if ITK_VERSION_MAJOR <= 4
void SetMutexImage(const typename MutexImageType::Pointer input) {
m_MutexImage=input;
this->Modified();
m_ThreadSafe=true;
}
+#else
+ void SetMutexImage() {
+ this->Modified();
+ m_ThreadSafe=true;
+ }
+#endif
//Get methods
typename WeightsImageType::Pointer GetWeights() {
//member data
typename WeightsImageType::Pointer m_Weights;
+#if ITK_VERSION_MAJOR <= 4
typename MutexImageType::Pointer m_MutexImage;
+#else
+ std::mutex m_Mutex;
+#endif
bool m_ThreadSafe;
};
for(dim = 0; dim < ImageDimension; dim++) {
// The following block is equivalent to the following line without
// having to call floor. (Only for positive inputs, we already now that is in the image)
- // baseIndex[dim] = (long) vcl_floor(contIndex[dim] );
+ // baseIndex[dim] = (long) std::floor(contIndex[dim] );
baseIndex[dim] = (long) contIndex[dim];
distance[dim] = contIndex[dim] - double( baseIndex[dim] );
else {
//Entering critilal section: shared memory
+#if ITK_VERSION_MAJOR <= 4
m_MutexImage->GetPixel(neighIndex).Lock();
+#else
+ m_Mutex.lock();
+#endif
//Set the pixel and weight at neighIndex
outputPtr->SetPixel(neighIndex, outputPtr->GetPixel(neighIndex) - (displacement*overlap));
m_Weights->SetPixel(neighIndex, m_Weights->GetPixel(neighIndex) + overlap);
//Unlock
+#if ITK_VERSION_MAJOR <= 4
m_MutexImage->GetPixel(neighIndex).Unlock();
+#else
+ m_Mutex.unlock();
+#endif
}
//Add to total overlap
typename HelperClass1Type::Pointer helper1=HelperClass1Type::New();
//Set input
- if(m_NumberOfThreadsIsGiven)helper1->SetNumberOfThreads(m_NumberOfThreads);
+ if(m_NumberOfThreadsIsGiven) {
+#if ITK_VERSION_MAJOR <= 4
+ helper1->SetNumberOfThreads(m_NumberOfThreads);
+#else
+ helper1->SetNumberOfWorkUnits(m_NumberOfWorkUnits);
+#endif
+ }
helper1->SetInput(inputPtr);
helper1->SetWeights(weights);
//Threadsafe?
if(m_ThreadSafe) {
//Allocate the mutex image
+#if ITK_VERSION_MAJOR <= 4
typename MutexImageType::Pointer mutex=InvertVFFilter::MutexImageType::New();
mutex->SetRegions(region);
mutex->Allocate();
mutex->SetSpacing(inputPtr->GetSpacing());
helper1->SetMutexImage(mutex);
+#else
+ helper1->SetMutexImage();
+#endif
if (m_Verbose) std::cout <<"Inverting using a thread-safe algorithm" <<std::endl;
} else if(m_Verbose)std::cout <<"Inverting using a thread-unsafe algorithm" <<std::endl;
typename HelperClass2Type::Pointer helper2=HelperClass2Type::New();
//Set temporary output as input
- if(m_NumberOfThreadsIsGiven)helper2->SetNumberOfThreads(m_NumberOfThreads);
+ if(m_NumberOfThreadsIsGiven) {
+#if ITK_VERSION_MAJOR <= 4
+ helper2->SetNumberOfThreads(m_NumberOfThreads);
+#else
+ helper2->SetNumberOfWorkUnits(m_NumberOfWorkUnits);
+#endif
+ }
helper2->SetInput(temp);
helper2->SetWeights(weights);
helper2->SetEdgePaddingValue(m_EdgePaddingValue);