STYLE: Deref sampler input and output at the start of GenerateData()

`Deref` checks that the input and output pointers are not null. It appears more secure to just do that right at the begin of the `GenerateData()` member function of these ImageSamplers.

Author: N-Dekker

Common/ImageSamplers/itkImageRandomCoordinateSampler.hxx

@@ -34,12 +34,12 @@ void
 ImageRandomCoordinateSampler<TInputImage>::GenerateData()
 {
   /** Get handles to the input image, output sample container, and interpolator. */
-  InputImageConstPointer                     inputImage = this->GetInput();
-  typename ImageSampleContainerType::Pointer sampleContainer = this->GetOutput();
-  typename InterpolatorType::Pointer         interpolator = this->GetModifiableInterpolator();
+  const InputImageType &             inputImage = elastix::Deref(this->GetInput());
+  ImageSampleContainerType &         sampleContainer = elastix::Deref(this->GetOutput());
+  typename InterpolatorType::Pointer interpolator = this->GetModifiableInterpolator();
 
   /** Set up the interpolator. */
-  interpolator->SetInputImage(inputImage); // only once?
+  interpolator->SetInputImage(&inputImage); // only once?
 
   const auto croppedInputImageRegion = this->GetCroppedInputImageRegion();
 
@@ -57,7 +57,7 @@ ImageRandomCoordinateSampler<TInputImage>::GenerateData()
   typename MaskType::ConstPointer mask = this->GetMask();
   if (mask.IsNull() && Superclass::m_UseMultiThread)
   {
-    auto & samples = elastix::Deref(sampleContainer).CastToSTLContainer();
+    auto & samples = sampleContainer.CastToSTLContainer();
     samples.resize(this->Superclass::m_NumberOfSamples);
 
     /** Clear the random number list. */
@@ -73,7 +73,7 @@ ImageRandomCoordinateSampler<TInputImage>::GenerateData()
       m_RandomCoordinates.push_back(randomCIndex);
     }
 
-    m_OptionalUserData.emplace(m_RandomCoordinates, *inputImage, *interpolator, samples);
+    m_OptionalUserData.emplace(m_RandomCoordinates, inputImage, *interpolator, samples);
 
     MultiThreaderBase & multiThreader = elastix::Deref(this->ProcessObject::GetMultiThreader());
     multiThreader.SetSingleMethod(&Self::ThreaderCallback, &*m_OptionalUserData);
@@ -82,18 +82,18 @@ ImageRandomCoordinateSampler<TInputImage>::GenerateData()
   }
 
   /** Reserve memory for the output. */
-  sampleContainer->Reserve(this->GetNumberOfSamples());
+  sampleContainer.Reserve(this->GetNumberOfSamples());
 
   /** Setup an iterator over the output, which is of ImageSampleContainerType. */
   typename ImageSampleContainerType::Iterator      iter;
-  typename ImageSampleContainerType::ConstIterator end = sampleContainer->End();
+  typename ImageSampleContainerType::ConstIterator end = sampleContainer.End();
 
   InputImageContinuousIndexType sampleContIndex;
   /** Fill the sample container. */
   if (mask.IsNull())
   {
     /** Start looping over the sample container. */
-    for (iter = sampleContainer->Begin(); iter != end; ++iter)
+    for (iter = sampleContainer.Begin(); iter != end; ++iter)
     {
       /** Make a reference to the current sample in the container. */
       InputImagePointType &  samplePoint = iter->Value().m_ImageCoordinates;
@@ -103,7 +103,7 @@ ImageRandomCoordinateSampler<TInputImage>::GenerateData()
       this->GenerateRandomCoordinate(smallestContIndex, largestContIndex, sampleContIndex);
 
       /** Convert to point */
-      inputImage->TransformContinuousIndexToPhysicalPoint(sampleContIndex, samplePoint);
+      inputImage.TransformContinuousIndexToPhysicalPoint(sampleContIndex, samplePoint);
 
       /** Compute the value at the continuous index. */
       sampleValue = static_cast<ImageSampleValueType>(this->m_Interpolator->EvaluateAtContinuousIndex(sampleContIndex));
@@ -121,7 +121,7 @@ ImageRandomCoordinateSampler<TInputImage>::GenerateData()
     unsigned long maximumNumberOfSamplesToTry = 10 * this->GetNumberOfSamples();
 
     /** Start looping over the sample container */
-    for (iter = sampleContainer->Begin(); iter != end; ++iter)
+    for (iter = sampleContainer.Begin(); iter != end; ++iter)
     {
       /** Make a reference to the current sample in the container. */
       InputImagePointType &  samplePoint = iter->Value().m_ImageCoordinates;
@@ -135,17 +135,17 @@ ImageRandomCoordinateSampler<TInputImage>::GenerateData()
         if (numberOfSamplesTried > maximumNumberOfSamplesToTry)
         {
           /** Squeeze the sample container to the size that is still valid. */
-          typename ImageSampleContainerType::iterator stlnow = sampleContainer->begin();
-          typename ImageSampleContainerType::iterator stlend = sampleContainer->end();
+          typename ImageSampleContainerType::iterator stlnow = sampleContainer.begin();
+          typename ImageSampleContainerType::iterator stlend = sampleContainer.end();
           stlnow += iter.Index();
-          sampleContainer->erase(stlnow, stlend);
+          sampleContainer.erase(stlnow, stlend);
           itkExceptionMacro(
             << "Could not find enough image samples within reasonable time. Probably the mask is too small");
         }
 
         /** Generate a point in the input image region. */
         this->GenerateRandomCoordinate(smallestContIndex, largestContIndex, sampleContIndex);
-        inputImage->TransformContinuousIndexToPhysicalPoint(sampleContIndex, samplePoint);
+        inputImage.TransformContinuousIndexToPhysicalPoint(sampleContIndex, samplePoint);
 
       } while (!interpolator->IsInsideBuffer(sampleContIndex) || !mask->IsInsideInWorldSpace(samplePoint));
 

Common/ImageSamplers/itkImageRandomSampler.hxx

@@ -37,20 +37,19 @@ void
 ImageRandomSampler<TInputImage>::GenerateData()
 {
   /** Get handles to the input image, output sample container. */
-  InputImageConstPointer                     inputImage = this->GetInput();
-  typename ImageSampleContainerType::Pointer sampleContainer = this->GetOutput();
+  const InputImageType &     inputImage = elastix::Deref(this->GetInput());
+  ImageSampleContainerType & sampleContainer = elastix::Deref(this->GetOutput());
 
   /** Get a handle to the mask. If there was no mask supplied we exercise a multi-threaded version. */
   typename MaskType::ConstPointer mask = this->GetMask();
   if (mask.IsNull() && Superclass::m_UseMultiThread)
   {
     Superclass::GenerateRandomNumberList();
     const auto & randomNumberList = Superclass::m_RandomNumberList;
-    auto &       samples = elastix::Deref(sampleContainer).CastToSTLContainer();
+    auto &       samples = sampleContainer.CastToSTLContainer();
     samples.resize(randomNumberList.size());
 
-    m_OptionalUserData.emplace(
-      randomNumberList, elastix::Deref(inputImage), this->GetCroppedInputImageRegion(), samples);
+    m_OptionalUserData.emplace(randomNumberList, inputImage, this->GetCroppedInputImageRegion(), samples);
 
     MultiThreaderBase & multiThreader = elastix::Deref(this->ProcessObject::GetMultiThreader());
     multiThreader.SetSingleMethod(&Self::ThreaderCallback, &*m_OptionalUserData);
@@ -59,11 +58,11 @@ ImageRandomSampler<TInputImage>::GenerateData()
   }
 
   /** Reserve memory for the output. */
-  sampleContainer->Reserve(this->GetNumberOfSamples());
+  sampleContainer.Reserve(this->GetNumberOfSamples());
 
   /** Setup a random iterator over the input image. */
   using RandomIteratorType = ImageRandomConstIteratorWithIndex<InputImageType>;
-  RandomIteratorType randIter(inputImage, this->GetCroppedInputImageRegion());
+  RandomIteratorType randIter(&inputImage, this->GetCroppedInputImageRegion());
 
   if (const auto optionalSeed = Superclass::GetOptionalSeed())
   {
@@ -73,19 +72,19 @@ ImageRandomSampler<TInputImage>::GenerateData()
 
   /** Setup an iterator over the output, which is of ImageSampleContainerType. */
   typename ImageSampleContainerType::Iterator      iter;
-  typename ImageSampleContainerType::ConstIterator end = sampleContainer->End();
+  typename ImageSampleContainerType::ConstIterator end = sampleContainer.End();
 
   if (mask.IsNull())
   {
     /** number of samples + 1, because of the initial ++randIter. */
     randIter.SetNumberOfSamples(this->GetNumberOfSamples() + 1);
     /** Advance one, in order to generate the same sequence as when using a mask */
     ++randIter;
-    for (iter = sampleContainer->Begin(); iter != end; ++iter)
+    for (iter = sampleContainer.Begin(); iter != end; ++iter)
     {
       /** Get the index, transform it to the physical coordinates and put it in the sample. */
       InputImageIndexType index = randIter.GetIndex();
-      inputImage->TransformIndexToPhysicalPoint(index, iter->Value().m_ImageCoordinates);
+      inputImage.TransformIndexToPhysicalPoint(index, iter->Value().m_ImageCoordinates);
       /** Get the value and put it in the sample. */
       iter->Value().m_ImageValue = randIter.Get();
       /** Jump to a random position. */
@@ -104,7 +103,7 @@ ImageRandomSampler<TInputImage>::GenerateData()
     /** Loop over the sample container. */
     InputImagePointType inputPoint;
     bool                insideMask = false;
-    for (iter = sampleContainer->Begin(); iter != end; ++iter)
+    for (iter = sampleContainer.Begin(); iter != end; ++iter)
     {
       /** Loop until a valid sample is found. */
       do
@@ -115,16 +114,16 @@ ImageRandomSampler<TInputImage>::GenerateData()
         if (randIter.IsAtEnd())
         {
           /** Squeeze the sample container to the size that is still valid. */
-          typename ImageSampleContainerType::iterator stlnow = sampleContainer->begin();
-          typename ImageSampleContainerType::iterator stlend = sampleContainer->end();
+          typename ImageSampleContainerType::iterator stlnow = sampleContainer.begin();
+          typename ImageSampleContainerType::iterator stlend = sampleContainer.end();
           stlnow += iter.Index();
-          sampleContainer->erase(stlnow, stlend);
+          sampleContainer.erase(stlnow, stlend);
           itkExceptionMacro(
             << "Could not find enough image samples within reasonable time. Probably the mask is too small");
         }
         /** Get the index, and transform it to the physical coordinates. */
         InputImageIndexType index = randIter.GetIndex();
-        inputImage->TransformIndexToPhysicalPoint(index, inputPoint);
+        inputImage.TransformIndexToPhysicalPoint(index, inputPoint);
         /** Check if it's inside the mask. */
         insideMask = mask->IsInsideInWorldSpace(inputPoint);
       } while (!insideMask);

Common/ImageSamplers/itkImageRandomSamplerSparseMask.hxx

@@ -42,16 +42,16 @@ ImageRandomSamplerSparseMask<TInputImage>::GenerateData()
   }
 
   /** Get handles to the input image and output sample container. */
-  InputImageConstPointer      inputImage = this->GetInput();
-  ImageSampleContainerPointer sampleContainer = this->GetOutput();
+  const InputImageType &     inputImage = elastix::Deref(this->GetInput());
+  ImageSampleContainerType & sampleContainer = elastix::Deref(this->GetOutput());
 
   // Take capacity from the output container, and clear it.
   std::vector<ImageSampleType> sampleVector;
-  sampleContainer->swap(sampleVector);
+  sampleContainer.swap(sampleVector);
   sampleVector.clear();
 
   /** Make sure the internal full sampler is up-to-date. */
-  this->m_InternalFullSampler->SetInput(inputImage);
+  this->m_InternalFullSampler->SetInput(&inputImage);
   this->m_InternalFullSampler->SetMask(mask);
   this->m_InternalFullSampler->SetInputImageRegion(this->GetCroppedInputImageRegion());
   this->m_InternalFullSampler->SetUseMultiThread(Superclass::m_UseMultiThread);
@@ -82,8 +82,8 @@ ImageRandomSamplerSparseMask<TInputImage>::GenerateData()
   }
 
   /** Get a handle to the full sampler output. */
-  typename ImageSampleContainerType::Pointer allValidSamples = this->m_InternalFullSampler->GetOutput();
-  unsigned long                              numberOfValidSamples = allValidSamples->Size();
+  const ImageSampleContainerType & allValidSamples = elastix::Deref(this->m_InternalFullSampler->GetOutput());
+  unsigned long                    numberOfValidSamples = allValidSamples.Size();
 
 
   /** If desired we exercise a multi-threaded version. */
@@ -97,10 +97,10 @@ ImageRandomSamplerSparseMask<TInputImage>::GenerateData()
       m_RandomIndices.push_back(m_RandomGenerator->GetIntegerVariate(numberOfValidSamples - 1));
     }
 
-    auto & samples = elastix::Deref(sampleContainer).CastToSTLContainer();
+    auto & samples = sampleContainer.CastToSTLContainer();
     samples.resize(m_RandomIndices.size());
 
-    m_OptionalUserData.emplace(elastix::Deref(allValidSamples).CastToSTLConstContainer(), m_RandomIndices, samples);
+    m_OptionalUserData.emplace(allValidSamples.CastToSTLConstContainer(), m_RandomIndices, samples);
 
     MultiThreaderBase & multiThreader = elastix::Deref(this->ProcessObject::GetMultiThreader());
     multiThreader.SetSingleMethod(&Self::ThreaderCallback, &*m_OptionalUserData);
@@ -112,11 +112,11 @@ ImageRandomSamplerSparseMask<TInputImage>::GenerateData()
   for (unsigned int i = 0; i < this->GetNumberOfSamples(); ++i)
   {
     unsigned long randomIndex = this->m_RandomGenerator->GetIntegerVariate(numberOfValidSamples - 1);
-    sampleVector.push_back(allValidSamples->ElementAt(randomIndex));
+    sampleVector.push_back(allValidSamples.ElementAt(randomIndex));
   }
 
   // Move the samples from the vector into the output container.
-  sampleContainer->swap(sampleVector);
+  sampleContainer.swap(sampleVector);
 
 } // end GenerateData()