BUG: Update path information typedef, method, and member names.

thewtex · thewtex · commit ec08762581b1 · 2015-09-21T13:35:27.000-04:00
For consistency.
diff --git a/examples/example.cxx b/examples/example.cxx
@@ -73,11 +73,12 @@ end[0] = 100; end[1] = 10;
 way1[0] = 10; way1[1] = 10;
 
 // Add path information
-PathFilterType::PathInfo info;
-info.SetStartPoint( start );
-info.SetEndPoint( end );
-info.AddWayPoint( way1 );
-pathFilter->AddPathInfo( info );
+typedef PathFilterType::PathInformationType PathInformationType;
+PathInformationType::Pointer info = PathInformationType::New();
+info->SetStartPoint( start );
+info->SetEndPoint( end );
+info->AddWayPoint( way1 );
+pathFilter->AddPathInformation( info );
 
 // Compute the path
 pathFilter->Update( );
@@ -180,11 +181,12 @@ end[0] = 100; end[1] = 10;
 way1[0] = 10; way1[1] = 10;
 
 // Add path information
-PathFilterType::PathInfo info;
-info.SetStartPoint( start );
-info.SetEndPoint( end );
-info.AddWayPoint( way1 );
-pathFilter->AddPathInfo( info );
+typedef PathFilterType::PathInformationType PathInformationType;
+PathInformationType::Pointer info = PathInformationType::New();
+info->SetStartPoint( start );
+info->SetEndPoint( end );
+info->AddWayPoint( way1 );
+pathFilter->AddPathInformation( info );
 
 // Compute the path
 pathFilter->Update( );
diff --git a/include/itkSpeedFunctionPathInformation.h b/include/itkSpeedFunctionPathInformation.h
@@ -94,7 +94,7 @@ class SpeedFunctionPathInformation :
   virtual ~SpeedFunctionPathInformation( );
   virtual void PrintSelf( std::ostream& os, Indent indent ) const;
 
-  std::vector< PointType > m_Info;
+  std::vector< PointType > m_Information;
   SizeValueType            m_Front;
 
 
diff --git a/include/itkSpeedFunctionPathInformation.hxx b/include/itkSpeedFunctionPathInformation.hxx
@@ -42,8 +42,8 @@ template <typename TPoint>
 void SpeedFunctionPathInformation<TPoint>
 ::ClearInfo()
 {
-  m_Info.clear();
-  m_Info.resize(2);
+  m_Information.clear();
+  m_Information.resize(2);
   m_Front = 1;
 }
 
@@ -52,23 +52,23 @@ template <typename TPoint>
 void SpeedFunctionPathInformation<TPoint>
 ::SetStartPoint( const PointType & start )
 {
-  m_Info[1] = start;
+  m_Information[1] = start;
 }
 
 
 template <typename TPoint>
 void SpeedFunctionPathInformation<TPoint>
 ::SetEndPoint( const PointType & end )
 {
-  m_Info[0] = end;
+  m_Information[0] = end;
 }
 
 
 template <typename TPoint>
 void SpeedFunctionPathInformation<TPoint>
 ::AddWayPoint( const PointType & way )
 {
-  m_Info.push_back( way );
+  m_Information.push_back( way );
   m_Front++;
 }
 
@@ -77,7 +77,7 @@ template <typename TPoint>
 unsigned int SpeedFunctionPathInformation<TPoint>
 ::GetNumberOfPoints( ) const
 {
-  return m_Info.size();
+  return m_Information.size();
 }
 
 
@@ -86,7 +86,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &
 SpeedFunctionPathInformation<TPoint>
 ::GetStartPoint( ) const
 {
-  return m_Info[1];
+  return m_Information[1];
 }
 
 
@@ -95,7 +95,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &
 SpeedFunctionPathInformation<TPoint>
 ::GetEndPoint( ) const
 {
-  return m_Info[0];
+  return m_Information[0];
 }
 
 
@@ -104,7 +104,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &
 SpeedFunctionPathInformation<TPoint>
 ::GetWayPoint( SizeValueType i ) const
 {
-  return m_Info[2+i];
+  return m_Information[2+i];
 }
 
 
@@ -122,7 +122,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &
 SpeedFunctionPathInformation<TPoint>
 ::GetCurrentFrontAndAdvance( )
 {
-  return m_Info[m_Front--];
+  return m_Information[m_Front--];
 }
 
 
@@ -131,7 +131,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &
 SpeedFunctionPathInformation<TPoint>
 ::PeekCurrentFront( ) const
 {
-  return m_Info[m_Front];
+  return m_Information[m_Front];
 }
 
 
@@ -142,11 +142,11 @@ SpeedFunctionPathInformation<TPoint>
 {
   if ( m_Front <= 1 )
   {
-  return m_Info[1];
+  return m_Information[1];
   }
   else
   {
-  return m_Info[m_Front-1];
+  return m_Information[m_Front-1];
   }
 }
 
@@ -156,13 +156,13 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &
 SpeedFunctionPathInformation<TPoint>
 ::PeekPreviousFront( ) const
 {
-  if ( m_Front == m_Info.size()-1 )
+  if ( m_Front == m_Information.size()-1 )
   {
-  return m_Info[0];
+  return m_Information[0];
   }
   else
   {
-  return m_Info[m_Front+1];
+  return m_Information[m_Front+1];
   }
 }
 
diff --git a/include/itkSpeedFunctionToPathFilter.h b/include/itkSpeedFunctionToPathFilter.h
@@ -103,7 +103,7 @@ class ITK_EXPORT SpeedFunctionToPathFilter :
   typedef typename Superclass::OptimizerType       OptimizerType;
 
   /** Path information typedef. */
-  typedef SpeedFunctionPathInformation<PointType> PathInformation;
+  typedef SpeedFunctionPathInformation<PointType> PathInformationType;
 
   /** Override superclass behaviour.
    *  Warning: SetPathEndPoint() is not valid for this filter.
@@ -134,15 +134,15 @@ class ITK_EXPORT SpeedFunctionToPathFilter :
 
   /** Add a path information object to process.
    *  At least one PathInfo object must be added before processing. */
-  void AddPathInfo(PathInformation * info )
+  void AddPathInformation(PathInformationType * info )
   {
-    m_Info.push_back( info );
+    m_Information.push_back( info );
   }
 
   /** Clear the list of path information objects. */
-  void ClearPathInfo()
+  void ClearPathInformation()
   {
-    m_Info.clear( );
+    m_Information.clear( );
   }
 
   /** Handle optimizer iteration events. */
@@ -165,8 +165,8 @@ class ITK_EXPORT SpeedFunctionToPathFilter :
   /** Override handling of optimizer iteration events to accomodate way points. */
   virtual const PointType & GetNextEndPoint( );
 
-  std::vector< typename PathInformation::Pointer > m_Info;
-  InputImagePointer                                m_CurrentArrivalFunction;
+  std::vector< typename PathInformationType::Pointer > m_Information;
+  InputImagePointer                                    m_CurrentArrivalFunction;
 
 private:
   SpeedFunctionToPathFilter( const Self& ); //purposely not implemented
diff --git a/include/itkSpeedFunctionToPathFilter.hxx b/include/itkSpeedFunctionToPathFilter.hxx
@@ -55,7 +55,7 @@ unsigned int
 SpeedFunctionToPathFilter<TInputImage,TOutputPath>
 ::GetNumberOfPathsToExtract() const
 {
-  return m_Info.size();
+  return m_Information.size();
 }
 
 
@@ -67,7 +67,7 @@ const typename SpeedFunctionToPathFilter<TInputImage,TOutputPath>::PointType &
 SpeedFunctionToPathFilter<TInputImage,TOutputPath>
 ::GetNextEndPoint()
 {
-  return m_Info[Superclass::m_CurrentOutput]->GetEndPoint();
+  return m_Information[Superclass::m_CurrentOutput]->GetEndPoint();
 }
 
 
@@ -101,12 +101,12 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>
   IndexType indexTargetNext;
   speed->TransformPhysicalPointToIndex
     (
-    m_Info[Superclass::m_CurrentOutput]->PeekPreviousFront(),
+    m_Information[Superclass::m_CurrentOutput]->PeekPreviousFront(),
     indexTargetPrevious
     );
   speed->TransformPhysicalPointToIndex
     (
-    m_Info[Superclass::m_CurrentOutput]->PeekNextFront(),
+    m_Information[Superclass::m_CurrentOutput]->PeekNextFront(),
     indexTargetNext
     );
   NodeType nodeTargetPrevious;
@@ -125,7 +125,7 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>
   IndexType indexTrial;
   speed->TransformPhysicalPointToIndex
     (
-    m_Info[Superclass::m_CurrentOutput]->GetCurrentFrontAndAdvance(),
+    m_Information[Superclass::m_CurrentOutput]->GetCurrentFrontAndAdvance(),
     indexTrial
     );
   NodeType nodeTrial;
@@ -161,7 +161,7 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>
     }
 
   // Ensure the user has added at least one path info object
-  if ( m_Info.size() == 0 )
+  if ( m_Information.size() == 0 )
     {
     itkExceptionMacro( "No PathInfo objects: at least one must be added." );
     }
@@ -205,7 +205,7 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>
 
   // Check if we have reached the termination value
   if ( currentValue < Superclass::m_TerminationValue &&
-       m_Info[Superclass::m_CurrentOutput]->HasNextFront() )
+       m_Information[Superclass::m_CurrentOutput]->HasNextFront() )
     {
     // We have terminated the current path segment,
     // but there are more fronts to propagate
diff --git a/test/MinimalPathTest.h b/test/MinimalPathTest.h
@@ -1,5 +1,5 @@
 /*=========================================================================
-  
+
   Filter:    MinimalPath
   Program:   Insight Segmentation & Registration Toolkit
   Module:    MinimalPathTests.cxx
@@ -84,16 +84,16 @@ int ReadPathFile( const char * PathFilename, typename PathFilterType::Pointer pa
     while ( itksys::SystemTools::GetLineFromStream(file, line, &has_newline) )
     {
         if (has_newline)
-        {   
-	    typename PathInfoType::Pointer info = PathInfoType::New();  
+        {
+	    typename PathInfoType::Pointer info = PathInfoType::New();
             itksys::SystemTools::ReplaceString( line, "Path: ", "" );
             itksys::SystemTools::ReplaceString( line, " ", "" );
             itksys::SystemTools::ReplaceString( line, "[", "" );
             std::vector<itksys::String> parts;
             parts = itksys::SystemTools::SplitString( line.c_str(), ']' );
             unsigned int numNonNullParts = 0;
             for (unsigned int i=0; i<parts.size(); i++)
-                if ( parts[i].length() != 0 ) numNonNullParts++;                
+                if ( parts[i].length() != 0 ) numNonNullParts++;
             for (unsigned int i=0; i<numNonNullParts; i++)
             {
                 if ( parts[i].length() != 0 )
@@ -108,7 +108,7 @@ int ReadPathFile( const char * PathFilename, typename PathFilterType::Pointer pa
                     else info->AddWayPoint( point );
                 }
             }
-            pathFilter->AddPathInfo( info );
+            pathFilter->AddPathInformation( info );
         }
     }
 
@@ -203,7 +203,7 @@ int Test_SpeedToPath_GradientDescent_ND(int argc, char* argv[])
         std::cout << std::setprecision(3) << "Path computed in: " << time.GetMean() << " seconds" << std::endl;
 
         // Allocate output image
-        typename OutputImageType::Pointer output = OutputImageType::New();    
+        typename OutputImageType::Pointer output = OutputImageType::New();
         output->SetRegions( speed->GetLargestPossibleRegion() );
         output->SetSpacing( speed->GetSpacing() );
         output->SetOrigin( speed->GetOrigin() );
@@ -240,9 +240,9 @@ int Test_SpeedToPath_GradientDescent_ND(int argc, char* argv[])
         writer->Update();
     }
     catch (itk::ExceptionObject & err)
-    { 
-        std::cerr << "ExceptionObject caught !" << std::endl; 
-        std::cerr << err << std::endl; 
+    {
+        std::cerr << "ExceptionObject caught !" << std::endl;
+        std::cerr << err << std::endl;
         return EXIT_FAILURE;
     }
 
@@ -351,7 +351,7 @@ int Test_SpeedToPath_RegularStepGradientDescent_ND(int argc, char* argv[])
         std::cout << std::setprecision(3) << "Path computed in: " << time.GetMean() << " seconds" << std::endl;
 
         // Allocate output image
-        typename OutputImageType::Pointer output = OutputImageType::New();    
+        typename OutputImageType::Pointer output = OutputImageType::New();
         output->SetRegions( speed->GetLargestPossibleRegion() );
         output->SetSpacing( speed->GetSpacing() );
         output->SetOrigin( speed->GetOrigin() );
@@ -388,9 +388,9 @@ int Test_SpeedToPath_RegularStepGradientDescent_ND(int argc, char* argv[])
         writer->Update();
     }
     catch (itk::ExceptionObject & err)
-    { 
-        std::cerr << "ExceptionObject caught !" << std::endl; 
-        std::cerr << err << std::endl; 
+    {
+        std::cerr << "ExceptionObject caught !" << std::endl;
+        std::cerr << err << std::endl;
         return EXIT_FAILURE;
     }
 
@@ -491,7 +491,7 @@ int Test_SpeedToPath_IterateNeighborhood_ND(int argc, char* argv[])
         std::cout << std::setprecision(3) << "Path computed in: " << time.GetMean() << " seconds" << std::endl;
 
         // Allocate output image
-        typename OutputImageType::Pointer output = OutputImageType::New();    
+        typename OutputImageType::Pointer output = OutputImageType::New();
         output->SetRegions( speed->GetLargestPossibleRegion() );
         output->SetSpacing( speed->GetSpacing() );
         output->SetOrigin( speed->GetOrigin() );
@@ -528,9 +528,9 @@ int Test_SpeedToPath_IterateNeighborhood_ND(int argc, char* argv[])
         writer->Update();
     }
     catch (itk::ExceptionObject & err)
-    { 
-        std::cerr << "ExceptionObject caught !" << std::endl; 
-        std::cerr << err << std::endl; 
+    {
+        std::cerr << "ExceptionObject caught !" << std::endl;
+        std::cerr << err << std::endl;
         return EXIT_FAILURE;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ template <typename TPoint>`
`42`	`42`	`void SpeedFunctionPathInformation<TPoint>`
`43`	`43`	`::ClearInfo()`
`44`	`44`	`{`
`45`		`- m_Info.clear();`
`46`		`- m_Info.resize(2);`
	`45`	`+ m_Information.clear();`
	`46`	`+ m_Information.resize(2);`
`47`	`47`	`m_Front = 1;`
`48`	`48`	`}`
`49`	`49`
`@@ -52,23 +52,23 @@ template <typename TPoint>`
`52`	`52`	`void SpeedFunctionPathInformation<TPoint>`
`53`	`53`	`::SetStartPoint( const PointType & start )`
`54`	`54`	`{`
`55`		`- m_Info[1] = start;`
	`55`	`+ m_Information[1] = start;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`
`59`	`59`	`template <typename TPoint>`
`60`	`60`	`void SpeedFunctionPathInformation<TPoint>`
`61`	`61`	`::SetEndPoint( const PointType & end )`
`62`	`62`	`{`
`63`		`- m_Info[0] = end;`
	`63`	`+ m_Information[0] = end;`
`64`	`64`	`}`
`65`	`65`
`66`	`66`
`67`	`67`	`template <typename TPoint>`
`68`	`68`	`void SpeedFunctionPathInformation<TPoint>`
`69`	`69`	`::AddWayPoint( const PointType & way )`
`70`	`70`	`{`
`71`		`- m_Info.push_back( way );`
	`71`	`+ m_Information.push_back( way );`
`72`	`72`	`m_Front++;`
`73`	`73`	`}`
`74`	`74`
`@@ -77,7 +77,7 @@ template <typename TPoint>`
`77`	`77`	`unsigned int SpeedFunctionPathInformation<TPoint>`
`78`	`78`	`::GetNumberOfPoints( ) const`
`79`	`79`	`{`
`80`		`- return m_Info.size();`
	`80`	`+ return m_Information.size();`
`81`	`81`	`}`
`82`	`82`
`83`	`83`
`@@ -86,7 +86,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &`
`86`	`86`	`SpeedFunctionPathInformation<TPoint>`
`87`	`87`	`::GetStartPoint( ) const`
`88`	`88`	`{`
`89`		`- return m_Info[1];`
	`89`	`+ return m_Information[1];`
`90`	`90`	`}`
`91`	`91`
`92`	`92`
`@@ -95,7 +95,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &`
`95`	`95`	`SpeedFunctionPathInformation<TPoint>`
`96`	`96`	`::GetEndPoint( ) const`
`97`	`97`	`{`
`98`		`- return m_Info[0];`
	`98`	`+ return m_Information[0];`
`99`	`99`	`}`
`100`	`100`
`101`	`101`
`@@ -104,7 +104,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &`
`104`	`104`	`SpeedFunctionPathInformation<TPoint>`
`105`	`105`	`::GetWayPoint( SizeValueType i ) const`
`106`	`106`	`{`
`107`		`- return m_Info[2+i];`
	`107`	`+ return m_Information[2+i];`
`108`	`108`	`}`
`109`	`109`
`110`	`110`
`@@ -122,7 +122,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &`
`122`	`122`	`SpeedFunctionPathInformation<TPoint>`
`123`	`123`	`::GetCurrentFrontAndAdvance( )`
`124`	`124`	`{`
`125`		`- return m_Info[m_Front--];`
	`125`	`+ return m_Information[m_Front--];`
`126`	`126`	`}`
`127`	`127`
`128`	`128`
`@@ -131,7 +131,7 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &`
`131`	`131`	`SpeedFunctionPathInformation<TPoint>`
`132`	`132`	`::PeekCurrentFront( ) const`
`133`	`133`	`{`
`134`		`- return m_Info[m_Front];`
	`134`	`+ return m_Information[m_Front];`
`135`	`135`	`}`
`136`	`136`
`137`	`137`
`@@ -142,11 +142,11 @@ SpeedFunctionPathInformation<TPoint>`
`142`	`142`	`{`
`143`	`143`	`if ( m_Front <= 1 )`
`144`	`144`	`{`
`145`		`- return m_Info[1];`
	`145`	`+ return m_Information[1];`
`146`	`146`	`}`
`147`	`147`	`else`
`148`	`148`	`{`
`149`		`- return m_Info[m_Front-1];`
	`149`	`+ return m_Information[m_Front-1];`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`
`@@ -156,13 +156,13 @@ const typename SpeedFunctionPathInformation<TPoint>::PointType &`
`156`	`156`	`SpeedFunctionPathInformation<TPoint>`
`157`	`157`	`::PeekPreviousFront( ) const`
`158`	`158`	`{`
`159`		`- if ( m_Front == m_Info.size()-1 )`
	`159`	`+ if ( m_Front == m_Information.size()-1 )`
`160`	`160`	`{`
`161`		`- return m_Info[0];`
	`161`	`+ return m_Information[0];`
`162`	`162`	`}`
`163`	`163`	`else`
`164`	`164`	`{`
`165`		`- return m_Info[m_Front+1];`
	`165`	`+ return m_Information[m_Front+1];`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ unsigned int`
`55`	`55`	`SpeedFunctionToPathFilter<TInputImage,TOutputPath>`
`56`	`56`	`::GetNumberOfPathsToExtract() const`
`57`	`57`	`{`
`58`		`- return m_Info.size();`
	`58`	`+ return m_Information.size();`
`59`	`59`	`}`
`60`	`60`
`61`	`61`
`@@ -67,7 +67,7 @@ const typename SpeedFunctionToPathFilter<TInputImage,TOutputPath>::PointType &`
`67`	`67`	`SpeedFunctionToPathFilter<TInputImage,TOutputPath>`
`68`	`68`	`::GetNextEndPoint()`
`69`	`69`	`{`
`70`		`- return m_Info[Superclass::m_CurrentOutput]->GetEndPoint();`
	`70`	`+ return m_Information[Superclass::m_CurrentOutput]->GetEndPoint();`
`71`	`71`	`}`
`72`	`72`
`73`	`73`
`@@ -101,12 +101,12 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>`
`101`	`101`	`IndexType indexTargetNext;`
`102`	`102`	`speed->TransformPhysicalPointToIndex`
`103`	`103`	`(`
`104`		`- m_Info[Superclass::m_CurrentOutput]->PeekPreviousFront(),`
	`104`	`+ m_Information[Superclass::m_CurrentOutput]->PeekPreviousFront(),`
`105`	`105`	`indexTargetPrevious`
`106`	`106`	`);`
`107`	`107`	`speed->TransformPhysicalPointToIndex`
`108`	`108`	`(`
`109`		`- m_Info[Superclass::m_CurrentOutput]->PeekNextFront(),`
	`109`	`+ m_Information[Superclass::m_CurrentOutput]->PeekNextFront(),`
`110`	`110`	`indexTargetNext`
`111`	`111`	`);`
`112`	`112`	`NodeType nodeTargetPrevious;`
`@@ -125,7 +125,7 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>`
`125`	`125`	`IndexType indexTrial;`
`126`	`126`	`speed->TransformPhysicalPointToIndex`
`127`	`127`	`(`
`128`		`- m_Info[Superclass::m_CurrentOutput]->GetCurrentFrontAndAdvance(),`
	`128`	`+ m_Information[Superclass::m_CurrentOutput]->GetCurrentFrontAndAdvance(),`
`129`	`129`	`indexTrial`
`130`	`130`	`);`
`131`	`131`	`NodeType nodeTrial;`
`@@ -161,7 +161,7 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`// Ensure the user has added at least one path info object`
`164`		`- if ( m_Info.size() == 0 )`
	`164`	`+ if ( m_Information.size() == 0 )`
`165`	`165`	`{`
`166`	`166`	`itkExceptionMacro( "No PathInfo objects: at least one must be added." );`
`167`	`167`	`}`
`@@ -205,7 +205,7 @@ SpeedFunctionToPathFilter<TInputImage,TOutputPath>`
`205`	`205`
`206`	`206`	`// Check if we have reached the termination value`
`207`	`207`	`if ( currentValue < Superclass::m_TerminationValue &&`
`208`		`- m_Info[Superclass::m_CurrentOutput]->HasNextFront() )`
	`208`	`+ m_Information[Superclass::m_CurrentOutput]->HasNextFront() )`
`209`	`209`	`{`
`210`	`210`	`// We have terminated the current path segment,`
`211`	`211`	`// but there are more fronts to propagate`