~HelperClass1() {};
//the actual processing
- void GenerateInputRequestedRegion();
- void GenerateOutputInformation();
- void BeforeThreadedGenerateData();
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
+ void BeforeThreadedGenerateData() ITK_OVERRIDE;
+ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE;
//member data
typename WeightsImageType::Pointer m_Weights;
m_ThreadSafe=false;
}
-//=========================================================================================================================
-//Set input image params
-template <class InputImageType, class OutputImageType>
-void HelperClass1<InputImageType, OutputImageType>::GenerateInputRequestedRegion()
-{
- //std::cout << "HelperClass1::GenerateInputRequestedRegion - IN" << std::endl;
-
- typename InputImageType::Pointer inputPtr = const_cast< InputImageType * >(this->GetInput());
- inputPtr->SetRequestedRegion(inputPtr->GetLargestPossibleRegion());
-
- //std::cout << "HelperClass1::GenerateInputRequestedRegion - OUT" << std::endl;
-}
-
-//=========================================================================================================================
-//Set output image params
-template<class InputImageType, class OutputImageType >
-void HelperClass1<InputImageType, OutputImageType>::GenerateOutputInformation()
-{
- //std::cout << "HelperClass1::GenerateOutputInformation - IN" << std::endl;
- Superclass::GenerateOutputInformation();
-
- // it's the weight image that determines the size of the output
- typename OutputImageType::Pointer outputPtr = this->GetOutput();
- outputPtr->SetLargestPossibleRegion( m_Weights->GetLargestPossibleRegion() );
- outputPtr->SetSpacing(m_Weights->GetSpacing());
-}
-
//=========================================================================================================================
//Before threaded data
template<class InputImageType, class OutputImageType >
//=========================================================================================================================
//update the output for the outputRegionForThread
template<class InputImageType, class OutputImageType>
-void HelperClass1<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId )
+void HelperClass1<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId )
{
- //std::cout << "HelperClass1::ThreadedGenerateData - IN" << std::endl;
+// std::cout << "HelperClass1::ThreadedGenerateData - IN " << threadId << std::endl;
//Get pointer to the input
typename InputImageType::ConstPointer inputPtr = this->GetInput();
//Get pointer to the output
typename OutputImageType::Pointer outputPtr = this->GetOutput();
-/* outputPtr->SetLargestPossibleRegion( m_Weights->GetLargestPossibleRegion() );
- outputPtr->SetSpacing(m_Weights->GetSpacing());*/
- typename OutputImageType::SizeType size=outputPtr->GetLargestPossibleRegion().GetSize();
- //std::cout << outputPtr->GetSpacing() << size << std::endl;
+ //typename OutputImageType::SizeType size=outputPtr->GetLargestPossibleRegion().GetSize();
//Iterator over input
- //typedef itk::ImageRegionConstIteratorWithIndex<InputImageType> InputImageIteratorType;
- typedef itk::ImageRegionConstIteratorWithIndex<OutputImageType> InputImageIteratorType;
+ typedef itk::ImageRegionConstIteratorWithIndex<InputImageType> InputImageIteratorType;
//define them over the outputRegionForThread
- //InputImageIteratorType outputIt(inputPtr, outputRegionForThread);
- InputImageIteratorType outputIt(outputPtr, outputPtr->GetLargestPossibleRegion());
+ InputImageIteratorType inputIt(inputPtr, outputRegionForThread);
//Initialize
typename InputImageType::IndexType index;
typename OutputImageType::PointType opoint;
typedef typename OutputImageType::PixelType DisplacementType;
DisplacementType displacement;
- outputIt.GoToBegin();
+ inputIt.GoToBegin();
+
+ typename OutputImageType::SizeType size = outputPtr->GetLargestPossibleRegion().GetSize();
//define some temp variables
signed long baseIndex[ImageDimension];
double distance[ImageDimension];
unsigned int dim, counter, upper;
double totalOverlap,overlap;
- typename OutputImageType::IndexType neighIndex, outIndex;
+ typename OutputImageType::IndexType neighIndex;
//Find the number of neighbors
unsigned int neighbors = 1 << ImageDimension;
//==================================================================================================
//Loop over the output region and add the intensities from the input to the output and the weight to the weights
//==================================================================================================
- while( !outputIt.IsAtEnd() ) {
+ while( !inputIt.IsAtEnd() ) {
// get the input image index
- outIndex = outputIt.GetIndex();
- outputPtr->TransformIndexToPhysicalPoint( outIndex,opoint );
- for(unsigned int j = 0; j < ImageDimension; j++ ) ipoint[j] = opoint[j];
- inputPtr->TransformPhysicalPointToIndex(ipoint, index);
+ index = inputIt.GetIndex();
inputPtr->TransformIndexToPhysicalPoint( index,ipoint );
// get the required displacement
- //displacement = outputIt.Get();
- displacement = inputPtr->GetPixel(index);
+ displacement = inputIt.Get();
// compute the required output image point
for(unsigned int j = 0; j < ImageDimension; j++ ) opoint[j] = ipoint[j] + (double)displacement[j];
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] );
overlap *= 1.0 - distance[dim];
}
upper >>= 1;
- }
+ if (neighIndex[dim] >= size[dim])
+ neighIndex[dim] = size[dim] - 1;
+ }
//Set neighbor value only if overlap is not zero
}
}
- ++outputIt;
+ ++inputIt;
}
- //std::cout << "HelperClass1::ThreadedGenerateData - OUT" << std::endl;
+// std::cout << "HelperClass1::ThreadedGenerateData - OUT " << threadId << std::endl;
}
//the actual processing
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId );
-
+ void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId ) ITK_OVERRIDE;
//member data
typename WeightsImageType::Pointer m_Weights;
//Empty constructor
template<class InputImageType, class OutputImageType > HelperClass2<InputImageType, OutputImageType>::HelperClass2()
{
- m_EdgePaddingValue=itk::NumericTraits<PixelType>::Zero;
+ PixelType zero;
+ for(unsigned int i=0;i <PixelType::Dimension; i++) zero[i] = 0.0;
+ m_EdgePaddingValue=zero;
+ //m_EdgePaddingValue=itk::NumericTraits<PixelType>::Zero;
}
//=========================================================================================================================
//update the output for the outputRegionForThread
-template<class InputImageType, class OutputImageType > void HelperClass2<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, int threadId )
+template<class InputImageType, class OutputImageType > void HelperClass2<InputImageType, OutputImageType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId )
{
- //std::cout << "HelperClass2::ThreadedGenerateData - IN" << std::endl;
-
+// std::cout << "HelperClass2::ThreadedGenerateData - IN " << threadId << std::endl;
+
//Get pointer to the input
typename InputImageType::ConstPointer inputPtr = this->GetInput();
++inputIt;
}//end while
-
- //std::cout << "HelperClass2::ThreadedGenerateData - OUT" << std::endl;
-
+
+// std::cout << "HelperClass2::ThreadedGenerateData - OUT " << threadId << std::endl;
+
}//end member
template <class InputImageType, class OutputImageType>
InvertVFFilter<InputImageType, OutputImageType>::InvertVFFilter()
{
- m_EdgePaddingValue=itk::NumericTraits<PixelType>::Zero; //no other reasonable value?
- m_ThreadSafe=false;
- m_Verbose=false;
-}
-
-//=========================================================================================================================
-//Set input image params
-template <class InputImageType, class OutputImageType>
-void InvertVFFilter<InputImageType, OutputImageType>::GenerateInputRequestedRegion()
-{
- //std::cout << "InvertVFFilter::GenerateInputRequestedRegion - IN" << std::endl;
- // call the superclass' implementation of this method
- // Superclass::GenerateInputRequestedRegion();
-
- typename InputImageType::Pointer inputPtr = const_cast< InputImageType * >(this->GetInput());
- inputPtr->SetRequestedRegion(inputPtr->GetLargestPossibleRegion());
-
- //std::cout << "InvertVFFilter::GenerateInputRequestedRegion - OUT" << std::endl;
-}
-//=========================================================================================================================
-//Set output image params
-template<class InputImageType, class OutputImageType >
-void InvertVFFilter<InputImageType, OutputImageType>::GenerateOutputInformation()
-{
- //std::cout << "InvertVFFilter::GenerateOutputInformation - IN" << std::endl;
- Superclass::GenerateOutputInformation();
+ //m_EdgePaddingValue=itk::NumericTraits<PixelType>::Zero; //no other reasonable value?
+ PixelType zero;
+ for(unsigned int i=0;i <PixelType::Dimension; i++) zero[i] = 0.0;
+ m_EdgePaddingValue=zero; //no other reasonable value?
- typename InputImageType::ConstPointer inputPtr=this->GetInput();
- typename WeightsImageType::RegionType region = inputPtr->GetLargestPossibleRegion();
- region.SetSize(m_OutputSize);
-
- typename OutputImageType::Pointer outputPtr = this->GetOutput();
- outputPtr->SetRegions( region );
- outputPtr->SetSpacing(m_OutputSpacing);
- outputPtr->SetOrigin(inputPtr->GetOrigin());
-
- //std::cout << "InvertVFFilter::GenerateOutputInformation - OUT" << std::endl;
+ m_ThreadSafe=false;
+ m_Verbose=false;
}
//=========================================================================================================================
//Update
template <class InputImageType, class OutputImageType> void InvertVFFilter<InputImageType, OutputImageType>::GenerateData()
{
- //std::cout << "InvertVFFilter::GenerateData - IN" << std::endl;
+ // std::cout << "InvertVFFilter::GenerateData - IN" << std::endl;
//Get the properties of the input
typename InputImageType::ConstPointer inputPtr=this->GetInput();
typename WeightsImageType::RegionType region = inputPtr->GetLargestPossibleRegion();
- //region.SetSize(size);
- region.SetSize(m_OutputSize);
//Allocate the weights
typename WeightsImageType::Pointer weights=WeightsImageType::New();
weights->SetOrigin(inputPtr->GetOrigin());
weights->SetRegions(region);
- weights->SetSpacing(m_OutputSpacing);
weights->Allocate();
- //weights->SetSpacing(inputPtr->GetSpacing());
+ weights->SetSpacing(inputPtr->GetSpacing());
//===========================================================================
//Inversion is divided in in two loops, for each we will call a threaded helper class
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);
typename MutexImageType::Pointer mutex=InvertVFFilter::MutexImageType::New();
mutex->SetRegions(region);
mutex->Allocate();
- //mutex->SetSpacing(inputPtr->GetSpacing());
- mutex->SetSpacing(m_OutputSpacing);
+ mutex->SetSpacing(inputPtr->GetSpacing());
helper1->SetMutexImage(mutex);
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
- //std::cout << temp->GetSpacing() << temp->GetLargestPossibleRegion().GetSize() << std::endl;
- //std::cout << weights->GetSpacing() << weights->GetLargestPossibleRegion().GetSize() << std::endl;
+ 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);
//Set the output
this->SetNthOutput(0, helper2->GetOutput());
+
+ //std::cout << "InvertVFFilter::GenerateData - OUT" << std::endl;
}
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff