Re #6: Cleaned up class names and which classes are nodes in Slicer s…

…cene.

Logic/vtkSlicerLinearObjectRegistrationLogic.h

@@ -44,12 +44,12 @@
 
 // LinearObjectRegistration includes
 #include "vtkMRMLLinearObjectRegistrationNode.h"
-#include "vtkMRMLLORLinearObjectCollectionNode.h"
-#include "vtkMRMLLORPointNode.h"
-#include "vtkMRMLLORLineNode.h"
-#include "vtkMRMLLORPlaneNode.h"
-#include "vtkMRMLLORReferenceNode.h"
-#include "vtkMRMLLORPositionBufferNode.h"
+#include "vtkMRMLLinearObjectCollectionNode.h"
+#include "vtkLORPoint.h"
+#include "vtkLORLine.h"
+#include "vtkLORPlane.h"
+#include "vtkLORReference.h"
+#include "vtkLORPositionBuffer.h"
 #include "vtkSlicerLinearObjectRegistrationModuleLogicExport.h"
 
 
@@ -99,50 +99,50 @@ vtkSlicerLinearObjectRegistrationLogic : public vtkSlicerModuleLogic
   void CalculateTransform( vtkMRMLNode* node );
   void UpdateOutputTransform( vtkMRMLLinearTransformNode* outputTransform, vtkMatrix4x4* newTransformMatrix );
 
-  vtkSmartPointer< vtkMatrix4x4 > SphericalRegistration( vtkMRMLLORPositionBufferNode* fromPoints, vtkMRMLLORPositionBufferNode* toPoints, vtkMatrix4x4* currentFromToToTransform );
+  vtkSmartPointer< vtkMatrix4x4 > SphericalRegistration( vtkLORPositionBuffer* fromPoints, vtkLORPositionBuffer* toPoints, vtkMatrix4x4* currentFromToToTransform );
   std::vector<double> TranslationalRegistration( std::vector<double> toCentroid, std::vector<double> fromCentroid, vtkMatrix4x4* rotation );
-  std::vector<double> TranslationalAdjustment( vtkMRMLLORPositionBufferNode* fromPositions, vtkMRMLLORPositionBufferNode* toPositions, vtkMatrix4x4* currentFromToToTransform );
+  std::vector<double> TranslationalAdjustment( vtkLORPositionBuffer* fromPositions, vtkLORPositionBuffer* toPositions, vtkMatrix4x4* currentFromToToTransform );
 
   void VNLMatrixToVTKMatrix( vnl_matrix<double>* vnlMatrix, vtkMatrix4x4* vtkMatrix );
   void MatrixRotationPart( vtkMatrix4x4* matrix, vtkMatrix4x4* rotation );
   std::vector<double> MatrixTranslationPart( vtkMatrix4x4* matrix );
   void RotationTranslationToMatrix( vtkMatrix4x4* rotation, std::vector<double> translation, vtkMatrix4x4* matrix );
 
-  double LinearObjectICPTA( vtkMRMLLORLinearObjectCollectionNode* fromLinearObjects, vtkMRMLLORLinearObjectCollectionNode* toLinearObjects, vtkMatrix4x4* initialRotation, vtkMatrix4x4* calculatedMatrix );
+  double LinearObjectICPTA( vtkMRMLLinearObjectCollectionNode* fromLinearObjects, vtkMRMLLinearObjectCollectionNode* toLinearObjects, vtkMatrix4x4* initialRotation, vtkMatrix4x4* calculatedMatrix );
 
   vtkSmartPointer< vtkMatrix4x4 > CombineRotationAndTranslation( vtkMatrix4x4* rotation, std::vector<double> translation );
 
-  void FindClosestPositions( vtkMRMLLORLinearObjectCollectionNode* fromLinearObjects, vtkMRMLLORLinearObjectCollectionNode* toLinearObjects, vtkMatrix4x4* currentFromToToTransform,
-                    vtkMRMLLORPositionBufferNode* fromPositions, vtkMRMLLORPositionBufferNode* toPositions );
+  void FindClosestPositions( vtkMRMLLinearObjectCollectionNode* fromLinearObjects, vtkMRMLLinearObjectCollectionNode* toLinearObjects, vtkMatrix4x4* currentFromToToTransform,
+                    vtkLORPositionBuffer* fromPositions, vtkLORPositionBuffer* toPositions );
 
   std::string GetOutputMessage( std::string nodeID );
   void SetOutputMessage( std::string nodeID, std::string newOutputMessage );
 
-  vtkSmartPointer< vtkMRMLLORLinearObjectNode > PositionBufferToLinearObject( vtkMRMLLORPositionBufferNode* positionBuffer, double noiseThreshold, int dof = -1 );
+  vtkSmartPointer< vtkLORLinearObject > PositionBufferToLinearObject( vtkLORPositionBuffer* positionBuffer, double noiseThreshold, int dof = -1 );
 
-  vtkMRMLLORLinearObjectCollectionNode* GetActiveCollectionNode();
-  void SetActiveCollectionNode( vtkMRMLLORLinearObjectCollectionNode* newActiveCollectionNode );
+  vtkMRMLLinearObjectCollectionNode* GetActiveCollectionNode();
+  void SetActiveCollectionNode( vtkMRMLLinearObjectCollectionNode* newActiveCollectionNode );
 
-  void MatchCollections( vtkMRMLLORLinearObjectCollectionNode* collection0, vtkMRMLLORLinearObjectCollectionNode* collection1, double matchingThreshold, bool removeUnmatched = false );
-  void PairCollections( vtkMRMLLORLinearObjectCollectionNode* collection0, vtkMRMLLORLinearObjectCollectionNode* collection1 );
-  vtkSmartPointer< vtkMRMLLORLinearObjectCollectionNode > GetReferences( vtkMRMLLORLinearObjectCollectionNode* collection );
-  vtkSmartPointer< vtkMRMLLORLinearObjectCollectionNode > GetNonReferences( vtkMRMLLORLinearObjectCollectionNode* collection );
+  void MatchCollections( vtkMRMLLinearObjectCollectionNode* collection0, vtkMRMLLinearObjectCollectionNode* collection1, double matchingThreshold, bool removeUnmatched = false );
+  void PairCollections( vtkMRMLLinearObjectCollectionNode* collection0, vtkMRMLLinearObjectCollectionNode* collection1 );
+  vtkSmartPointer< vtkMRMLLinearObjectCollectionNode > GetReferences( vtkMRMLLinearObjectCollectionNode* collection );
+  vtkSmartPointer< vtkMRMLLinearObjectCollectionNode > GetNonReferences( vtkMRMLLinearObjectCollectionNode* collection );
 
-  void CreateLinearObjectModelHierarchyNode( vtkMRMLLORLinearObjectNode* linearObject, vtkMRMLLORLinearObjectCollectionNode* collection );
-  void CreateLinearObjectCollectionModelHierarchyNode( vtkMRMLLORLinearObjectCollectionNode* collection );
-  void CreateLinearObjectModelHierarchyNodes( vtkMRMLLORLinearObjectCollectionNode* collection );
+  void CreateLinearObjectModelHierarchyNode( vtkLORLinearObject* linearObject, vtkMRMLLinearObjectCollectionNode* collection );
+  void CreateLinearObjectCollectionModelHierarchyNode( vtkMRMLLinearObjectCollectionNode* collection );
+  void CreateLinearObjectModelHierarchyNodes( vtkMRMLLinearObjectCollectionNode* collection );
 
-  void ShowLinearObjectModel( vtkMRMLLORLinearObjectNode* linearObject );
-  void HideLinearObjectModel( vtkMRMLLORLinearObjectNode* linearObject );
-  bool GetLinearObjectModelVisibility( vtkMRMLLORLinearObjectNode* linearObject );
+  void ShowLinearObjectModel( vtkLORLinearObject* linearObject );
+  void HideLinearObjectModel( vtkLORLinearObject* linearObject );
+  bool GetLinearObjectModelVisibility( vtkLORLinearObject* linearObject );
 
-  void ShowLinearObjectCollectionModel( vtkMRMLLORLinearObjectCollectionNode* collection );
-  void HideLinearObjectCollectionModel( vtkMRMLLORLinearObjectCollectionNode* collection );
-  bool GetLinearObjectCollectionModelVisibility( vtkMRMLLORLinearObjectCollectionNode* collection );
+  void ShowLinearObjectCollectionModel( vtkMRMLLinearObjectCollectionNode* collection );
+  void HideLinearObjectCollectionModel( vtkMRMLLinearObjectCollectionNode* collection );
+  bool GetLinearObjectCollectionModelVisibility( vtkMRMLLinearObjectCollectionNode* collection );
 
   // Only to be called from the register method
-  void GetFromAndToCollections( vtkMRMLLORLinearObjectCollectionNode* fromCollection, vtkMRMLLORLinearObjectCollectionNode* fromReferenceCollection, vtkMRMLLORLinearObjectCollectionNode* fromPointCollection, vtkMRMLLORLinearObjectCollectionNode* fromLineCollection, vtkMRMLLORLinearObjectCollectionNode* fromPlaneCollection,
-                          vtkMRMLLORLinearObjectCollectionNode* toCollection, vtkMRMLLORLinearObjectCollectionNode* toReferenceCollection, vtkMRMLLORLinearObjectCollectionNode* toPointCollection, vtkMRMLLORLinearObjectCollectionNode* toLineCollection, vtkMRMLLORLinearObjectCollectionNode* toPlaneCollection );
+  void GetFromAndToCollections( vtkMRMLLinearObjectCollectionNode* fromCollection, vtkMRMLLinearObjectCollectionNode* fromReferenceCollection, vtkMRMLLinearObjectCollectionNode* fromPointCollection, vtkMRMLLinearObjectCollectionNode* fromLineCollection, vtkMRMLLinearObjectCollectionNode* fromPlaneCollection,
+                          vtkMRMLLinearObjectCollectionNode* toCollection, vtkMRMLLinearObjectCollectionNode* toReferenceCollection, vtkMRMLLinearObjectCollectionNode* toPointCollection, vtkMRMLLinearObjectCollectionNode* toLineCollection, vtkMRMLLinearObjectCollectionNode* toPlaneCollection );
 
 private:
 

MRML/CMakeLists.txt

@@ -15,26 +15,26 @@ set(${KIT}_INCLUDE_DIRECTORIES
 set(${KIT}_SRCS
   vtkMRMLLinearObjectRegistrationNode.cxx
   vtkMRMLLinearObjectRegistrationNode.h
-  vtkMRMLLORReferenceNode.cxx
-  vtkMRMLLORReferenceNode.h
-  vtkMRMLLORPositionBufferNode.cxx
-  vtkMRMLLORPositionBufferNode.h
-  vtkMRMLLORRealTimePositionBufferNode.cxx
-  vtkMRMLLORRealTimePositionBufferNode.h
-  vtkMRMLLORPositionNode.cxx
-  vtkMRMLLORPositionNode.h
-  vtkMRMLLORPointNode.cxx
-  vtkMRMLLORPointNode.h
-  vtkMRMLLORPlaneNode.cxx
-  vtkMRMLLORPlaneNode.h
-  vtkMRMLLORLinearObjectCollectionNode.cxx
-  vtkMRMLLORLinearObjectCollectionNode.h
-  vtkMRMLLORLinearObjectCollectionStorageNode.cxx
-  vtkMRMLLORLinearObjectCollectionStorageNode.h
-  vtkMRMLLORLinearObjectNode.cxx
-  vtkMRMLLORLinearObjectNode.h
-  vtkMRMLLORLineNode.cxx
-  vtkMRMLLORLineNode.h
+  vtkMRMLLinearObjectCollectionNode.cxx
+  vtkMRMLLinearObjectCollectionNode.h
+  vtkMRMLLinearObjectCollectionStorageNode.cxx
+  vtkMRMLLinearObjectCollectionStorageNode.h
+  vtkLORReference.cxx
+  vtkLORReference.h
+  vtkLORPositionBuffer.cxx
+  vtkLORPositionBuffer.h
+  vtkLORRealTimePositionBuffer.cxx
+  vtkLORRealTimePositionBuffer.h
+  vtkLORPosition.cxx
+  vtkLORPosition.h
+  vtkLORPoint.cxx
+  vtkLORPoint.h
+  vtkLORPlane.cxx
+  vtkLORPlane.h
+  vtkLORLinearObject.cxx
+  vtkLORLinearObject.h
+  vtkLORLine.cxx
+  vtkLORLine.h
   )
 
 SET (${KIT}_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR} CACHE INTERNAL "" FORCE)

MRML/vtkMRMLLORLineNode.cxx → MRML/vtkLORLine.cxx

@@ -1,37 +1,37 @@
 
-#include "vtkMRMLLORLineNode.h"
+#include "vtkLORLine.h"
 
-vtkStandardNewMacro( vtkMRMLLORLineNode )
+vtkStandardNewMacro( vtkLORLine )
 
 
-vtkMRMLLORLineNode* vtkMRMLLORLineNode
+vtkLORLine* vtkLORLine
 ::New( std::vector<double> newBasePoint, std::vector<double> newEndPoint )
 {
-  vtkMRMLLORLineNode* newLine = vtkMRMLLORLineNode::New();
+  vtkLORLine* newLine = vtkLORLine::New();
   newLine->BasePoint = newBasePoint;
   newLine->EndPoint = newEndPoint;
   return newLine;
 }
 
 
-vtkMRMLLORLineNode
-::vtkMRMLLORLineNode()
+vtkLORLine
+::vtkLORLine()
 {
   this->Type = "Line";
 }
 
 
-vtkMRMLLORLineNode
-::~vtkMRMLLORLineNode()
+vtkLORLine
+::~vtkLORLine()
 {
   this->EndPoint.clear();
 }
 
 
-vtkSmartPointer< vtkMRMLLORLinearObjectNode > vtkMRMLLORLineNode
+vtkSmartPointer< vtkLORLinearObject > vtkLORLine
 ::DeepCopy()
 {
-  vtkSmartPointer< vtkMRMLLORLineNode > objectNodeCopy = vtkSmartPointer< vtkMRMLLORLineNode >::New();
+  vtkSmartPointer< vtkLORLine > objectNodeCopy = vtkSmartPointer< vtkLORLine >::New();
 
   objectNodeCopy->BasePoint = this->BasePoint;
   objectNodeCopy->EndPoint = this->EndPoint;
@@ -50,23 +50,23 @@ ::DeepCopy()
 }
 
 
-std::vector<double> vtkMRMLLORLineNode
+std::vector<double> vtkLORLine
 ::GetDirection()
 {
-  std::vector<double> vector = vtkMRMLLORVectorMath::Subtract( this->EndPoint, this->BasePoint );
-  return vtkMRMLLORVectorMath::Multiply( 1 / vtkMRMLLORVectorMath::Norm( vector ), vector );
+  std::vector<double> vector = LORMath::Subtract( this->EndPoint, this->BasePoint );
+  return LORMath::Multiply( 1 / LORMath::Norm( vector ), vector );
 }
 
 
-std::vector<double> vtkMRMLLORLineNode
+std::vector<double> vtkLORLine
 ::ProjectVector( std::vector<double> vector )
 {
-  std::vector<double> outVec = vtkMRMLLORVectorMath::Subtract( vector, this->BasePoint );
-  return vtkMRMLLORVectorMath::Add( vtkMRMLLORVectorMath::Multiply( vtkMRMLLORVectorMath::Dot( this->GetDirection(), outVec ), this->GetDirection() ), this->BasePoint );
+  std::vector<double> outVec = LORMath::Subtract( vector, this->BasePoint );
+  return LORMath::Add( LORMath::Multiply( LORMath::Dot( this->GetDirection(), outVec ), this->GetDirection() ), this->BasePoint );
 }
 
 
-void vtkMRMLLORLineNode
+void vtkLORLine
 ::Translate( std::vector<double> vector )
 {
   for ( int i = 0; i < vector.size(); i++ )
@@ -77,7 +77,7 @@ ::Translate( std::vector<double> vector )
 }
 
 
-vtkPolyData* vtkMRMLLORLineNode
+vtkPolyData* vtkLORLine
 ::CreateModelPolyData()
 {
   vtkLineSource* lineSource = vtkLineSource::New();
@@ -99,9 +99,9 @@ ::CreateModelPolyData()
   for ( int i = 0; i < this->GetPositionBuffer()->Size(); i++ )
   {
     // Project onto line
-    std::vector<double> outVec = vtkMRMLLORVectorMath::Subtract( this->GetPositionBuffer()->GetPosition( i )->GetPositionVector(), this->BasePoint );
+    std::vector<double> outVec = LORMath::Subtract( this->GetPositionBuffer()->GetPosition( i )->GetPositionVector(), this->BasePoint );
 
-    double parameter = vtkMRMLLORVectorMath::Dot( this->GetDirection(), outVec );
+    double parameter = LORMath::Dot( this->GetDirection(), outVec );
 
     if ( parameter > maxParameter )
     {
@@ -113,11 +113,11 @@ ::CreateModelPolyData()
     }
   }
 
-  std::vector<double> maxVector = vtkMRMLLORVectorMath::Multiply( maxParameter, this->GetDirection() );
-  std::vector<double> minVector = vtkMRMLLORVectorMath::Multiply( minParameter, this->GetDirection() );
+  std::vector<double> maxVector = LORMath::Multiply( maxParameter, this->GetDirection() );
+  std::vector<double> minVector = LORMath::Multiply( minParameter, this->GetDirection() );
 
-  std::vector<double> point1 = vtkMRMLLORVectorMath::Add( this->BasePoint, minVector );
-  std::vector<double> point2 = vtkMRMLLORVectorMath::Add( this->BasePoint, maxVector );
+  std::vector<double> point1 = LORMath::Add( this->BasePoint, minVector );
+  std::vector<double> point2 = LORMath::Add( this->BasePoint, maxVector );
 
   lineSource->SetPoint1( point1.at(0), point1.at(1), point1.at(2) );
   lineSource->SetPoint2( point2.at(0), point2.at(1), point2.at(2) );
@@ -126,7 +126,7 @@ ::CreateModelPolyData()
 }
 
 
-std::vector<double> vtkMRMLLORLineNode
+std::vector<double> vtkLORLine
 ::GetOrthogonalNormal1()
 {
   // Find the two axis unit vectors least parallel with the direction vector
@@ -148,17 +148,17 @@ ::GetOrthogonalNormal1()
 	e2.at(0) = 0; e2.at(1) = 1; e2.at(2) = 0;
   }
 
-  std::vector<double> Normal1 = vtkMRMLLORVectorMath::Subtract( e1, vtkMRMLLORVectorMath::Multiply( vtkMRMLLORVectorMath::Dot( e1, this->GetDirection() ), this->GetDirection() ) );
-  Normal1 = vtkMRMLLORVectorMath::Multiply( 1 / vtkMRMLLORVectorMath::Norm( Normal1 ), Normal1 );
+  std::vector<double> Normal1 = LORMath::Subtract( e1, LORMath::Multiply( LORMath::Dot( e1, this->GetDirection() ), this->GetDirection() ) );
+  Normal1 = LORMath::Multiply( 1 / LORMath::Norm( Normal1 ), Normal1 );
 
-  std::vector<double> Normal2 = vtkMRMLLORVectorMath::Subtract( e2, vtkMRMLLORVectorMath::Add( vtkMRMLLORVectorMath::Multiply( vtkMRMLLORVectorMath::Dot( e2, this->GetDirection() ), this->GetDirection() ), vtkMRMLLORVectorMath::Multiply( vtkMRMLLORVectorMath::Dot( e2, Normal1 ), Normal1 ) ) );
-  Normal2 = vtkMRMLLORVectorMath::Multiply( 1 / vtkMRMLLORVectorMath::Norm( Normal2 ), Normal2 );
+  std::vector<double> Normal2 = LORMath::Subtract( e2, LORMath::Add( LORMath::Multiply( LORMath::Dot( e2, this->GetDirection() ), this->GetDirection() ), LORMath::Multiply( LORMath::Dot( e2, Normal1 ), Normal1 ) ) );
+  Normal2 = LORMath::Multiply( 1 / LORMath::Norm( Normal2 ), Normal2 );
 
   return Normal1;
 }
 
 
-std::vector<double> vtkMRMLLORLineNode
+std::vector<double> vtkLORLine
 ::GetOrthogonalNormal2()
 {
   // Find the two axis unit vectors least parallel with the direction vector
@@ -180,24 +180,24 @@ ::GetOrthogonalNormal2()
 	e2.at(0) = 0; e2.at(1) = 1; e2.at(2) = 0;
   }
 
-  std::vector<double> Normal1 = vtkMRMLLORVectorMath::Subtract( e1, vtkMRMLLORVectorMath::Multiply( vtkMRMLLORVectorMath::Dot( e1, this->GetDirection() ), this->GetDirection() ) );
-  Normal1 = vtkMRMLLORVectorMath::Multiply( 1 / vtkMRMLLORVectorMath::Norm( Normal1 ), Normal1 );
+  std::vector<double> Normal1 = LORMath::Subtract( e1, LORMath::Multiply( LORMath::Dot( e1, this->GetDirection() ), this->GetDirection() ) );
+  Normal1 = LORMath::Multiply( 1 / LORMath::Norm( Normal1 ), Normal1 );
 
-  std::vector<double> Normal2 = vtkMRMLLORVectorMath::Subtract( e2, vtkMRMLLORVectorMath::Add( vtkMRMLLORVectorMath::Multiply( vtkMRMLLORVectorMath::Dot( e2, this->GetDirection() ), this->GetDirection() ), vtkMRMLLORVectorMath::Multiply( vtkMRMLLORVectorMath::Dot( e2, Normal1 ), Normal1 ) ) );
-  Normal2 = vtkMRMLLORVectorMath::Multiply( 1 / vtkMRMLLORVectorMath::Norm( Normal2 ), Normal2 );
+  std::vector<double> Normal2 = LORMath::Subtract( e2, LORMath::Add( LORMath::Multiply( LORMath::Dot( e2, this->GetDirection() ), this->GetDirection() ), LORMath::Multiply( LORMath::Dot( e2, Normal1 ), Normal1 ) ) );
+  Normal2 = LORMath::Multiply( 1 / LORMath::Norm( Normal2 ), Normal2 );
 
   return Normal2;
 }
 
 
-std::string vtkMRMLLORLineNode
+std::string vtkLORLine
 ::ToXMLString()
 {
   std::stringstream xmlstring;
 
   xmlstring << "  <Line Name=\"" << this->Name << "\">" << std::endl;
-  xmlstring << "    <BasePoint Value=\"" << vtkMRMLLORVectorMath::VectorToString( this->BasePoint ) << "\"/>" << std::endl;
-  xmlstring << "    <EndPoint Value=\"" << vtkMRMLLORVectorMath::VectorToString( this->EndPoint ) << "\"/>" << std::endl;
+  xmlstring << "    <BasePoint Value=\"" << LORMath::VectorToString( this->BasePoint ) << "\"/>" << std::endl;
+  xmlstring << "    <EndPoint Value=\"" << LORMath::VectorToString( this->EndPoint ) << "\"/>" << std::endl;
 
   if ( this->GetPositionBuffer() != NULL )
   {
@@ -210,7 +210,7 @@ ::ToXMLString()
 }
 
 
-void vtkMRMLLORLineNode
+void vtkLORLine
 ::FromXMLElement( vtkXMLDataElement* element )
 {
 
@@ -230,15 +230,15 @@ ::FromXMLElement( vtkXMLDataElement* element )
 
 	if ( strcmp( noteElement->GetName(), "BasePoint" ) == 0 )
 	{
-      this->BasePoint = vtkMRMLLORVectorMath::StringToVector( std::string( noteElement->GetAttribute( "Value" ) ), vtkMRMLLORLinearObjectNode::DIMENSION );
+      this->BasePoint = LORMath::StringToVector( std::string( noteElement->GetAttribute( "Value" ) ), vtkLORLinearObject::DIMENSION );
 	}
 	if ( strcmp( noteElement->GetName(), "EndPoint" ) == 0 )
 	{
-      this->EndPoint = vtkMRMLLORVectorMath::StringToVector( std::string( noteElement->GetAttribute( "Value" ) ), vtkMRMLLORLinearObjectNode::DIMENSION );
+      this->EndPoint = LORMath::StringToVector( std::string( noteElement->GetAttribute( "Value" ) ), vtkLORLinearObject::DIMENSION );
 	}
 	if ( strcmp( noteElement->GetName(), "Buffer" ) == 0 )
 	{
-      vtkSmartPointer< vtkMRMLLORPositionBufferNode > bufferNode = vtkSmartPointer< vtkMRMLLORPositionBufferNode >::New();
+      vtkSmartPointer< vtkLORPositionBuffer > bufferNode = vtkSmartPointer< vtkLORPositionBuffer >::New();
 	  bufferNode->FromXMLElement( noteElement );
       this->SetPositionBuffer( bufferNode );
 	}

MRML/vtkMRMLLORLineNode.h → MRML/vtkLORLine.h

@@ -1,6 +1,6 @@
 
-#ifndef __vtkMRMLLORLineNode_h
-#define __vtkMRMLLORLineNode_h
+#ifndef __vtkLORLine_h
+#define __vtkLORLine_h
 
 
 // Standard includes
@@ -18,26 +18,26 @@
 #include "vtkLineSource.h"
 
 // LinearObjectRegistration includes
-#include "vtkMRMLLORLinearObjectNode.h"
+#include "vtkLORLinearObject.h"
 #include "vtkSlicerLinearObjectRegistrationModuleMRMLExport.h"
 
 // This class stores a vector of values and a string label
 class VTK_SLICER_LINEAROBJECTREGISTRATION_MODULE_MRML_EXPORT
-vtkMRMLLORLineNode : public vtkMRMLLORLinearObjectNode
+vtkLORLine : public vtkLORLinearObject
 {
 public:
-  vtkTypeMacro( vtkMRMLLORLineNode, vtkObject );
+  vtkTypeMacro( vtkLORLine, vtkObject );
 
-  static vtkMRMLLORLineNode* New();
-  static vtkMRMLLORLineNode* New( std::vector<double> newBasePoint, std::vector<double> newEndPoint );
+  static vtkLORLine* New();
+  static vtkLORLine* New( std::vector<double> newBasePoint, std::vector<double> newEndPoint );
 
-  vtkSmartPointer< vtkMRMLLORLinearObjectNode > DeepCopy();
+  vtkSmartPointer< vtkLORLinearObject > DeepCopy();
 
 protected:
 
   // Constructor/destructor
-  vtkMRMLLORLineNode();
-  virtual ~vtkMRMLLORLineNode();
+  vtkLORLine();
+  virtual ~vtkLORLine();
 
 
 public: