WIP #8: Training workflow segmentation algorithm is successful, and a…

…re results can be saved to and loaded from file.

CMakeLists.txt

@@ -45,11 +45,20 @@ set(MODULE_SRCS
   qSlicer${MODULE_NAME}Module.h
   qSlicer${MODULE_NAME}ModuleWidget.cxx
   qSlicer${MODULE_NAME}ModuleWidget.h
+  qSlicerWorkflowProcedureReader.cxx
+  qSlicerWorkflowProcedureReader.h
+  qSlicerWorkflowInputReader.cxx
+  qSlicerWorkflowInputReader.h
+  qSlicerWorkflowTrainingReader.cxx
+  qSlicerWorkflowTrainingReader.h
   )
 
 set(MODULE_MOC_SRCS
   qSlicer${MODULE_NAME}Module.h
   qSlicer${MODULE_NAME}ModuleWidget.h
+  qSlicerWorkflowProcedureReader.h
+  qSlicerWorkflowInputReader.h
+  qSlicerWorkflowTrainingReader.h
   )
 
 set(MODULE_UI_SRCS

Logic/vtkSlicerWorkflowSegmentationLogic.cxx

@@ -32,25 +32,29 @@
 vtkStandardNewMacro(vtkSlicerWorkflowSegmentationLogic);
 
 //----------------------------------------------------------------------------
-vtkSlicerWorkflowSegmentationLogic::vtkSlicerWorkflowSegmentationLogic()
+vtkSlicerWorkflowSegmentationLogic
+::vtkSlicerWorkflowSegmentationLogic()
 {
 }
 
 //----------------------------------------------------------------------------
-vtkSlicerWorkflowSegmentationLogic::~vtkSlicerWorkflowSegmentationLogic()
+vtkSlicerWorkflowSegmentationLogic
+::~vtkSlicerWorkflowSegmentationLogic()
 {
 }
 
 
 
-void vtkSlicerWorkflowSegmentationLogic::PrintSelf(ostream& os, vtkIndent indent)
+void vtkSlicerWorkflowSegmentationLogic
+::PrintSelf(ostream& os, vtkIndent indent)
 {
   this->Superclass::PrintSelf(os, indent);
 }
 
 
 
-void vtkSlicerWorkflowSegmentationLogic::InitializeEventListeners()
+void vtkSlicerWorkflowSegmentationLogic
+::InitializeEventListeners()
 {
   vtkNew<vtkIntArray> events;
   events->InsertNextValue(vtkMRMLScene::NodeAddedEvent);
@@ -61,23 +65,52 @@ void vtkSlicerWorkflowSegmentationLogic::InitializeEventListeners()
 
 
 
-void vtkSlicerWorkflowSegmentationLogic::RegisterNodes()
+void vtkSlicerWorkflowSegmentationLogic
+::RegisterNodes()
 {
-  //assert(this->GetMRMLScene() != 0);
-
+  //assert(this->GetMRMLScene() != 0);  
   if( ! this->GetMRMLScene() )
   {
     return;
   }
-  vtkMRMLWorkflowSegmentationNode* pNode = vtkMRMLWorkflowSegmentationNode::New();
-  this->GetMRMLScene()->RegisterNodeClass( pNode );
-  pNode->Delete(); 
+
+  vtkMRMLWorkflowSegmentationNode* wsNode = vtkMRMLWorkflowSegmentationNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( wsNode );
+  wsNode->Delete();
+
+  vtkMRMLWorkflowProcedureNode* wpNode = vtkMRMLWorkflowProcedureNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( wpNode );
+  wpNode->Delete();
 
+  vtkMRMLWorkflowProcedureStorageNode* wpsNode = vtkMRMLWorkflowProcedureStorageNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( wpsNode );
+  wpsNode->Delete();
+
+  vtkMRMLWorkflowInputNode* wiNode = vtkMRMLWorkflowInputNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( wiNode );
+  wiNode->Delete();
+
+  vtkMRMLWorkflowInputStorageNode* wisNode = vtkMRMLWorkflowInputStorageNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( wisNode );
+  wisNode->Delete();
+
+  vtkMRMLWorkflowTrainingNode* wtNode = vtkMRMLWorkflowTrainingNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( wtNode );
+  wtNode->Delete();
+
+  vtkMRMLWorkflowTrainingStorageNode* wtsNode = vtkMRMLWorkflowTrainingStorageNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( wtsNode );
+  wtsNode->Delete();
+
+  vtkMRMLWorkflowToolNode* toolNode = vtkMRMLWorkflowToolNode::New();
+  this->GetMRMLScene()->RegisterNodeClass( toolNode );
+  toolNode->Delete();  
 }
 
 
 
-void vtkSlicerWorkflowSegmentationLogic::UpdateFromMRMLScene()
+void vtkSlicerWorkflowSegmentationLogic
+::UpdateFromMRMLScene()
 {
   assert(this->GetMRMLScene() != 0);
 }
@@ -142,7 +175,7 @@ ::TrainAllTools( vtkMRMLWorkflowSegmentationNode* workflowNode, std::vector< std
     {
       continue;
     }
-    toolNode->GetWorkflowTrainingNode()->SetName( toolNode->GetWorkflowProcedureNode()->GetName() );
+    //toolNode->GetWorkflowTrainingNode()->SetName( toolNode->GetWorkflowProcedureNode()->GetName() );
 
     // Grab only the relevant components of the transform buffers
     std::vector< vtkSmartPointer< vtkWorkflowLogRecordBuffer > > trainingRecordBuffers;
@@ -151,7 +184,7 @@ ::TrainAllTools( vtkMRMLWorkflowSegmentationNode* workflowNode, std::vector< std
     {
       vtkMRMLTransformBufferNode* transformBuffer = vtkMRMLTransformBufferNode::SafeDownCast( this->GetMRMLScene()->GetNodeByID( trainingBufferIDs.at( j ) ) );
       vtkSmartPointer< vtkWorkflowLogRecordBuffer > recordBuffer = vtkSmartPointer< vtkWorkflowLogRecordBuffer >::New(); 
-      recordBuffer->FromTransformBufferNode( transformBuffer, toolNode->GetWorkflowProcedureNode()->GetName(), toolNode->GetWorkflowProcedureNode()->GetAllTaskNames() );
+      recordBuffer->FromTransformBufferNode( transformBuffer, toolNode->GetWorkflowProcedureNode()->GetProcedureName(), toolNode->GetWorkflowProcedureNode()->GetAllTaskNames() );
       trainingRecordBuffers.push_back( recordBuffer );
     }
 
@@ -226,7 +259,7 @@ ::GetToolStatusStrings( vtkMRMLWorkflowSegmentationNode* workflowNode )
     }
 
     std::stringstream toolStatus;
-    toolStatus << toolNode->GetName() << ": ";
+    toolStatus << toolNode->GetName() << " (" << toolNode->GetToolName() << "): ";
 
     if ( toolNode->GetInputted() )
     {

MRML/vtkLabelRecord.cxx

@@ -18,11 +18,17 @@ vtkLabelRecord
 
 
 void vtkLabelRecord
-::Copy( vtkLabelRecord* otherRecord )
+::Copy( vtkLogRecord* otherRecord )
 {
   this->vtkLogRecord::Copy( otherRecord );
+
+  vtkLabelRecord* labelRecord = vtkLabelRecord::SafeDownCast( otherRecord ); 
+  if ( labelRecord == NULL )
+  {
+    return;
+  }
 
-  this->GetVector()->Copy( otherRecord->GetVector() );
+  this->GetVector()->Copy( labelRecord->GetVector() );
 }
 
 

MRML/vtkLabelRecord.h

@@ -43,7 +43,7 @@ vtkLabelRecord : public vtkLogRecord
 public:
 
   // Copy
-  void Copy( vtkLabelRecord* otherRecord );
+  virtual void Copy( vtkLogRecord* otherRecord );
 
   enum TrackingRecordType
   {

MRML/vtkLabelVector.cxx

@@ -218,16 +218,27 @@ ::VectorsFromXMLElement( vtkXMLDataElement* element, std::string name )
     vtkSmartPointer< vtkLabelVector > currentVector = vtkSmartPointer< vtkLabelVector >::New();
 
     vtkXMLDataElement* noteElement = element->GetNestedElement( i );
-    if ( strcmp( noteElement->GetName(), name.c_str() ) != 0 )
-    {
-      continue;  // If it's not a "Parameter", jump to the next.
-    }
-
 	  currentVector->FromString( std::string( noteElement->GetAttribute( "Values" ) ), atoi( noteElement->GetAttribute( "Size" ) ) );
 	  currentVector->SetLabel( std::string( noteElement->GetAttribute( "Label" ) ) );
 
 	  vectors.push_back( currentVector );
   }
 
   return vectors;
-}
+}
+
+//
+//void vtkLabelVector
+//::CopyVector( std::vector< vtkSmartPointer< vtkLabelVector > > from, std::vector< vtkSmartPointer< vtkLabelVector > > to )
+//{
+//  to.clear();
+//
+//  // Deep copy every element of the vector
+//  for ( int i = 0; i < from.size(); i++ )
+//  {
+//    vtkSmartPointer< vtkLabelVector > currVector = vtkSmartPointer< vtkLabelVector >::New();
+//    currVector->Copy( from.at( i ) );
+//    to.push_back( currVector );
+//  }
+//
+//}

MRML/vtkLabelVector.h

@@ -66,6 +66,8 @@ vtkLabelVector : public vtkObject
   static std::string VectorsToXMLString( std::vector< vtkSmartPointer< vtkLabelVector > > vectors, std::string name, vtkIndent indent );
   static std::string VectorsToXMLString( vtkLabelVector* vector, std::string name, vtkIndent indent );
   static std::vector< vtkSmartPointer< vtkLabelVector > > VectorsFromXMLElement( vtkXMLDataElement* element, std::string name ); // Note: This will create the labels vectors, whoever uses the function is responsible for deleting
+
+  //static void CopyVector( std::vector< vtkSmartPointer< vtkLabelVector > > from, std::vector< vtkSmartPointer< vtkLabelVector > > to );
 
 protected:
 

MRML/vtkMRMLWorkflowInputNode.cxx

@@ -111,17 +111,19 @@ ::ToXMLString( vtkIndent indent )
 {
   std::stringstream xmlstring;
 
-  xmlstring << indent << "<Parameter Type=\"FilterWidth\" Value=\"" << this->FilterWidth << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"OrthogonalOrder\" Value=\"" << this->OrthogonalOrder << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"OrthogonalWindow\" Value=\"" << this->OrthogonalWindow << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"Derivative\" Value=\"" << this->Derivative << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"NumCentroids\" Value=\"" << this->NumCentroids << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"NumPrinComps\" Value=\"" << this->NumPrinComps << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"MarkovPseudoScalePi\" Value=\"" << this->MarkovPseudoScalePi << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"MarkovPseudoScaleA\" Value=\"" << this->MarkovPseudoScaleA << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"MarkovPseudoScaleB\" Value=\"" << this->MarkovPseudoScaleB << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"CompletionTime\" Value=\"" << this->CompletionTime << "\" />" << std::endl;
-  xmlstring << indent << "<Parameter Type=\"Equalization\" Value=\"" << this->Equalization << "\" />" << std::endl;
+  xmlstring << indent << "<WorkflowInput>" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"FilterWidth\" Value=\"" << this->FilterWidth << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"OrthogonalOrder\" Value=\"" << this->OrthogonalOrder << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"OrthogonalWindow\" Value=\"" << this->OrthogonalWindow << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"Derivative\" Value=\"" << this->Derivative << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"NumCentroids\" Value=\"" << this->NumCentroids << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"NumPrinComps\" Value=\"" << this->NumPrinComps << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"MarkovPseudoScalePi\" Value=\"" << this->MarkovPseudoScalePi << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"MarkovPseudoScaleA\" Value=\"" << this->MarkovPseudoScaleA << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"MarkovPseudoScaleB\" Value=\"" << this->MarkovPseudoScaleB << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"CompletionTime\" Value=\"" << this->CompletionTime << "\" />" << std::endl;
+  xmlstring << indent.GetNextIndent() << "<Parameter Type=\"Equalization\" Value=\"" << this->Equalization << "\" />" << std::endl;
+  xmlstring << indent << "</WorkflowInput>" << std::endl;
 
   return xmlstring.str();
 }

MRML/vtkMRMLWorkflowProcedureNode.cxx

@@ -62,6 +62,8 @@ ::Copy( vtkMRMLNode *anode )
   {
     return;
   }  
+
+  this->SetProcedureName( node->GetProcedureName() );
 
   this->Tasks.clear();
   std::map< std::string, vtkSmartPointer< vtkWorkflowTask > >::iterator itr;
@@ -141,12 +143,12 @@ ::ToXMLString( vtkIndent indent )
 {
   std::stringstream xmlstring;
 
-  xmlstring << indent << "<WorkflowProcedure>" << std::endl;
+  xmlstring << indent << "<WorkflowProcedure ProcedureName=\"" << this->ProcedureName << "\" >" << std::endl;
 
   std::map< std::string, vtkSmartPointer< vtkWorkflowTask > >::iterator itr;  
   for( itr = this->Tasks.begin(); itr != this->Tasks.end(); itr++ )
   {
-    itr->second->ToXMLString( indent.GetNextIndent() );
+    xmlstring << itr->second->ToXMLString( indent.GetNextIndent() );
   }
 
   xmlstring << indent << "</WorkflowProcedure>" << std::endl;
@@ -162,6 +164,8 @@ ::FromXMLElement( vtkXMLDataElement* element )
   {
     return;
   }
+
+  this->SetProcedureName( element->GetAttribute( "ProcedureName" ) );
 
   int numElements = element->GetNumberOfNestedElements();
 

MRML/vtkMRMLWorkflowSegmentationNode.cxx

@@ -77,6 +77,7 @@ void vtkMRMLWorkflowSegmentationNode::PrintSelf( ostream& os, vtkIndent indent )
 vtkMRMLWorkflowSegmentationNode
 ::vtkMRMLWorkflowSegmentationNode()
 {
+  this->AddNodeReferenceRole( TOOL_REFERENCE_ROLE );
 }