ENH: Initial support of the arc beam sequence

Beams/Logic/CMakeLists.txt

@@ -8,6 +8,8 @@ set(${KIT}_INCLUDE_DIRECTORIES
   ${SlicerRtCommon_INCLUDE_DIRS}
   ${vtkSlicerBeamsModuleMRML_INCLUDE_DIRS}
   ${vtkSlicerSubjectHierarchyModuleLogic_INCLUDE_DIRS}
+  ${vtkSlicerSequencesModuleMRML_INCLUDE_DIRS}
+  ${vtkSlicerSequencesModuleLogic_INCLUDE_DIRS}
   )
 
 set(${KIT}_SRCS
@@ -26,6 +28,8 @@ set(${KIT}_TARGET_LIBRARIES
   vtkSlicerRtCommon
   vtkSlicerMarkupsModuleMRML
   vtkSlicerSubjectHierarchyModuleLogic
+  vtkSlicerSequencesModuleMRML
+  vtkSlicerSequencesModuleLogic
   ${ITK_LIBRARIES}
   ${VTK_LIBRARIES}
   )

Beams/Logic/vtkSlicerBeamsModuleLogic.cxx

@@ -27,7 +27,20 @@
 #include "vtkMRMLRTPlanNode.h"
 #include "vtkMRMLRTBeamNode.h"
 
+#include <vtkSlicerRtCommon.h>
+
+// SubjectHierarchy includes
+#include "vtkMRMLSubjectHierarchyConstants.h"
+#include "vtkMRMLSubjectHierarchyNode.h"
+#include "vtkSlicerSubjectHierarchyModuleLogic.h"
+
+// Sequences inludes
+#include <vtkMRMLSequenceBrowserNode.h>
+#include <vtkMRMLSequenceNode.h>
+
 // MRML includes
+#include <vtkMRMLModelDisplayNode.h>
+#include <vtkMRMLModelHierarchyNode.h>
 #include <vtkMRMLScene.h>
 #include <vtkMRMLLinearTransformNode.h>
 #include <vtkMRMLMarkupsFiducialNode.h>
@@ -299,3 +312,263 @@ void vtkSlicerBeamsModuleLogic::ProcessMRMLNodesEvents(vtkObject* caller, unsign
     }
   }
 }
+
+//----------------------------------------------------------------------------
+bool vtkSlicerBeamsModuleLogic::CreateArcBeamDynamicSequence( 
+  double initialAngle, double finalAngle, double stepAngle, bool direction,
+  vtkMRMLRTPlanNode* planNode, vtkMRMLSequenceBrowserNode* beamSequenceBrowserNode,
+  vtkMRMLSequenceNode* beamSequenceNode, vtkMRMLSequenceNode* transformSequenceNode)
+{
+  std::vector<double> angles;
+  if (vtkSlicerRtCommon::AreEqualWithTolerance(finalAngle, initialAngle))
+  {
+    return false;
+  }
+
+  if (finalAngle < 0. && finalAngle > 360. && initialAngle < 0. && initialAngle > 360.)
+  {
+    return false;
+  }
+
+  if (!direction && initialAngle < finalAngle) // CW, ini < fin
+  {
+    for (double angle = initialAngle; angle <= finalAngle; angle += stepAngle)
+    {
+      angles.push_back(angle);
+    }
+    if (angles.back() < finalAngle)
+    {
+      angles.push_back(finalAngle);
+    }
+    std::cout << "Angles " << angles.size() << '\n';
+    std::for_each( angles.begin(), angles.end(), [](double v){ std::cout << v << ' '; });
+    std::cout << std::endl;
+  }
+  else if (!direction && initialAngle > finalAngle) // CW, ini > fin
+  {
+    for (double angle = initialAngle; angle <= 360.; angle += stepAngle)
+    {
+      angles.push_back(angle);
+    }
+    double startAngle = 1.;
+    if (angles.back() < 360.)
+    {
+      startAngle = angles.back() + stepAngle - 360.;
+    }
+    else if (angles.back() == 360.)
+    {
+      startAngle = stepAngle;
+    }
+
+    for (double angle = startAngle; angle <= finalAngle; angle += stepAngle)
+    {
+      angles.push_back(angle);
+    }
+    if (angles.back() < finalAngle)
+    {
+      angles.push_back(finalAngle);
+    }
+    std::cout << "Angles " << angles.size() << '\n';
+    std::for_each( angles.begin(), angles.end(), [](double v){ std::cout << v << ' '; });
+    std::cout << std::endl;
+  }
+  else if (direction && initialAngle < finalAngle) // CCW, ini < fin
+  {
+    for (double angle = initialAngle; angle >= 0.0; angle -= stepAngle)
+    {
+      angles.push_back(angle);
+    }
+    double startAngle = 359.;
+    if (angles.back() > 0.)
+    {
+      startAngle = angles.back() - stepAngle + 360.;
+    }
+    else if (angles.back() == 0.)
+    {
+      startAngle = 360. - stepAngle;
+    }
+    for (double angle = startAngle; angle >= finalAngle; angle -= stepAngle)
+    {
+      angles.push_back(angle);
+    }
+    if (angles.back() > finalAngle)
+    {
+      angles.push_back(finalAngle);
+    }
+    std::cout << "Angles " << angles.size() << '\n';
+    std::for_each( angles.begin(), angles.end(), [](double v){ std::cout << v << ' '; });
+    std::cout << std::endl;
+  }
+  else if (direction && initialAngle > finalAngle) // CCW, ini > fin
+  {
+    for (double angle = initialAngle; angle >= finalAngle; angle -= stepAngle)
+    {
+      angles.push_back(angle);
+    }
+    if (angles.back() > finalAngle)
+    {
+      angles.push_back(finalAngle);
+    }
+    std::cout << "Angles " << angles.size() << '\n';
+    std::for_each( angles.begin(), angles.end(), [](double v){ std::cout << v << ' '; });
+    std::cout << std::endl;
+  }
+/*
+  if (finalAngle < 0. && finalAngle > 360. && initialAngle < 0. && initialAngle > 360.)
+  {
+    return false;
+  }
+
+  if (!direction && initialAngle < finalAngle) // CW, ini < fin
+  {
+    for (double angle = initialAngle; angle <= finalAngle; angle += 1.)
+    {
+      angles.push_back(angle);
+    }
+  }
+  else if (!direction && initialAngle > finalAngle) // CW, ini > fin
+  {
+    for (double angle = initialAngle; angle <= 360.; angle += 1.)
+    {
+      angles.push_back(angle);
+    }
+    for (double angle = 1.; angle <= finalAngle; angle += 1.)
+    {
+      angles.push_back(angle);
+    }
+  }
+  else if (direction && initialAngle < finalAngle) // CCW, ini < fin
+  {
+    for (double angle = initialAngle; angle >= 0.0; angle -= 1.)
+    {
+      angles.push_back(angle);
+    }
+    for (double angle = 359.; angle >= finalAngle; angle -= 1.)
+    {
+      angles.push_back(angle);
+    }
+  }
+  else if (direction && initialAngle > finalAngle) // CCW, ini > fin
+  {
+    for (double angle = initialAngle; angle >= finalAngle; angle -= 1.)
+    {
+      angles.push_back(angle);
+    }
+  }
+*/
+  if (angles.size() < 2)
+  {
+    vtkErrorMacro("CreateArcBeamDynamicSequence: Number of angle elements is less than 2");
+    return false;
+  }
+
+  vtkMRMLScene* scene = planNode->GetScene();
+
+  vtkMRMLSubjectHierarchyNode* shNode = vtkMRMLSubjectHierarchyNode::GetSubjectHierarchyNode(scene);
+  if (!shNode)
+  {
+    vtkErrorMacro("CreateArcBeamDynamicSequence: Failed to access subject hierarchy node");
+    return false;
+  }
+  vtkSmartPointer<vtkMRMLModelHierarchyNode> beamModelHierarchyRootNode;
+
+  const char* beamName = "Beam [ArcDelivery]";
+  // Create sequence node for RTBeam, transformation, table
+
+  // beamSequenceNode
+  beamSequenceNode->SetName(beamName);
+  beamSequenceNode->SetIndexName("Control point");
+  beamSequenceNode->SetIndexUnit("index");
+  beamSequenceNode->SetIndexType(vtkMRMLSequenceNode::NumericIndex);
+
+  // transformSequenceNode
+  std::string name = std::string(beamName) + vtkMRMLRTBeamNode::BEAM_TRANSFORM_NODE_NAME_POSTFIX;
+  transformSequenceNode->SetName(name.c_str());
+  transformSequenceNode->SetIndexName("Control point");
+  transformSequenceNode->SetIndexUnit("index");
+  transformSequenceNode->SetIndexType(vtkMRMLSequenceNode::NumericIndex);
+
+  // beamSequenceBrowserNode
+  name = std::string(beamName) + "_SequenceBrowser";
+  beamSequenceBrowserNode->SetName(name.c_str());
+
+  // Add sequence nodes to the scene
+  scene->AddNode(beamSequenceNode);
+  scene->AddNode(transformSequenceNode);
+  scene->AddNode(beamSequenceBrowserNode);
+
+  for ( auto it = angles.begin(); it != angles.end(); ++it)
+  {
+    unsigned int controlPointIndex = it - angles.begin();
+    // Create the beam node for each control point
+    vtkSmartPointer<vtkMRMLRTBeamNode> beamNode = vtkSmartPointer<vtkMRMLRTBeamNode>::New();
+
+    std::ostringstream nameStream;
+    nameStream << beamName << " [Dynamic] : CP" << controlPointIndex;
+
+    std::string newBeamName = nameStream.str();
+    beamNode->SetName(newBeamName.c_str());
+
+    // Set beam geometry parameters from DICOM
+    double jawPositions[2][2] = {{-40.0, 40.0},{-40.0, 40.0}};
+    beamNode->SetX1Jaw(jawPositions[0][0]);
+    beamNode->SetX2Jaw(jawPositions[0][1]);
+    beamNode->SetY1Jaw(jawPositions[1][0]);
+    beamNode->SetY2Jaw(jawPositions[1][1]);
+
+    beamNode->SetGantryAngle(*it);
+
+    // SAD for RTPlan, source to beam limiting devices (Jaws, MLC)
+    if (beamNode)
+    {
+//      beamNode->SetSAD(rtReader->GetBeamSourceAxisDistance(dicomBeamNumber));
+//      beamNode->SetSourceToJawsDistanceX(rtReader->GetBeamSourceToJawsDistanceX(dicomBeamNumber));
+//      beamNode->SetSourceToJawsDistanceY(rtReader->GetBeamSourceToJawsDistanceY(dicomBeamNumber));
+//      beamNode->SetSourceToMultiLeafCollimatorDistance(rtReader->GetBeamSourceToMultiLeafCollimatorDistance(dicomBeamNumber));
+    }
+
+    // Add beam to beam sequence node
+    if (beamNode)
+    {
+      beamSequenceNode->SetDataNodeAtValue( beamNode, std::to_string(controlPointIndex));
+    }
+
+    // Get or create RTBeam transformation from RTPlan without adding beam to the plan
+    // Add beam transformation to transform sequence
+    vtkMRMLLinearTransformNode* transformNode = beamNode->CreateBeamTransformNode(scene);
+    if (transformNode)
+    {
+      double isocenter[3] = { 0., 0., 0.};
+      planNode->GetIsocenterPosition(isocenter);
+      {
+        // Update beam transform without translation to isocenter
+        this->UpdateTransformForBeam( beamSequenceNode->GetSequenceScene(), beamNode, transformNode, isocenter);
+
+        vtkTransform* transform = vtkTransform::SafeDownCast(transformNode->GetTransformToParent());
+        if (isocenter)
+        {
+          // Actual translation to isocenter
+          transform->Translate( isocenter[0], isocenter[1], isocenter[2]);
+          transformNode->Modified();
+        }
+
+        transformSequenceNode->SetDataNodeAtValue( transformNode, std::to_string(controlPointIndex));
+      }
+    }
+  } // end of a control point
+
+  // Synchronize beam sequence, beam transform sequence, table sequence nodes
+  beamSequenceBrowserNode->SetAndObserveMasterSequenceNodeID(beamSequenceNode->GetID());
+  beamSequenceBrowserNode->AddSynchronizedSequenceNode(transformSequenceNode);
+
+  // Get proxy beam node
+  vtkMRMLNode* node = beamSequenceBrowserNode->GetProxyNode(beamSequenceNode);
+  if (vtkMRMLRTBeamNode::SafeDownCast(node))
+  {
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+}

Beams/Logic/vtkSlicerBeamsModuleLogic.h

@@ -35,6 +35,8 @@
 #include "vtkMRMLRTBeamNode.h"
 
 class vtkSlicerMLCPositionLogic;
+class vtkMRMLSequenceBrowserNode;
+class vtkMRMLSequenceNode;
 
 /// \ingroup SlicerRt_QtModules_Beams
 class VTK_SLICER_BEAMS_LOGIC_EXPORT vtkSlicerBeamsModuleLogic :
@@ -60,6 +62,20 @@ class VTK_SLICER_BEAMS_LOGIC_EXPORT vtkSlicerBeamsModuleLogic :
   void UpdateTransformForBeam( vtkMRMLScene* beamSequenceScene, vtkMRMLRTBeamNode* beamNode, 
     vtkMRMLLinearTransformNode* beamTransformNode, double isocenter[3]);
 
+  /// Create arc delivery beam sequence 
+  /// @param initialAngle - initial angle in degrees
+  /// @param finalAngle - final angle in degrees
+  /// @param angleStep - single angle step within arc
+  /// @param direction - 0 - clockwise, 1 - counter-clockwise
+  /// @param planNode - input plan node, which contains reference volume node and isocenter position
+  /// @param sequenceBrowserNode - output sequence browser node
+  /// @param sequenceBeamNode - output beam node
+  /// @param sequenceTransformNode - output transform node
+  bool CreateArcBeamDynamicSequence( double initialAngle, double finalAngle,
+    double angleStep, bool direction, vtkMRMLRTPlanNode* planNode,
+    vtkMRMLSequenceBrowserNode* beamSequenceBrowserNode,
+    vtkMRMLSequenceNode* beamSequenceNode, vtkMRMLSequenceNode* transformSequenceNode);
+
 protected:
   vtkSlicerBeamsModuleLogic();
   ~vtkSlicerBeamsModuleLogic() override;

Beams/MRML/vtkMRMLRTBeamNode.cxx

@@ -916,9 +916,3 @@ void vtkMRMLRTBeamNode::CreateMLCPointsFromSectionBorder( double jawBegin,
   }
   side12.push_back(side2.back());
 }
-
-//----------------------------------------------------------------------------
-bool vtkMRMLRTBeamNode::AreEqual( double v1, double v2)
-{
-  return vtkSlicerRtCommon::AreEqualWithTolerance( v1, v2);
-}

Beams/MRML/vtkMRMLRTBeamNode.h

@@ -261,8 +261,6 @@ class VTK_SLICER_BEAMS_MODULE_MRML_EXPORT vtkMRMLRTBeamNode : public vtkMRMLMode
   void CreateMLCPointsFromSectionBorder( double jawBegin, double jawEnd, 
     bool mlcType, const MLCSectionVector::value_type& sectionBorder, 
     MLCVisiblePointVector& side12);
-
-  static bool AreEqual( double v1, double v2);
 };
 
 #endif // __vtkMRMLRTBeamNode_h

Beams/Widgets/Resources/UI/qMRMLBeamParametersTabWidget.ui

@@ -14,7 +14,7 @@
    <string>TabWidget</string>
   </property>
   <property name="currentIndex">
-   <number>0</number>
+   <number>2</number>
   </property>
   <widget class="QWidget" name="tabGeometry">
    <attribute name="title">

Beams/qSlicerBeamsModule.cxx

@@ -82,10 +82,9 @@ QStringList qSlicerBeamsModule::dependencies()const
 //-----------------------------------------------------------------------------
 QString qSlicerBeamsModule::helpText()const
 {
-  QString help = 
-    "This module displays and handles beam geometry models created from the loaded isocenter and source fiducials. "
-    "For more information see <a href=\"%1/Documentation/%2.%3/Modules/Beams\">%1/Documentation/%2.%3/Modules/Beams</a><br>";
-  return help.arg(this->slicerWikiUrl()).arg(Slicer_VERSION_MAJOR).arg(Slicer_VERSION_MINOR);
+  return QString("This module displays and handles beam geometry models created from the loaded isocenter and source fiducials. "
+    "For more information see <a href=\"%1/Documentation/%2.%3/Modules/Beams\">%1/Documentation/%2.%3/Modules/Beams</a><br>").arg(
+    this->slicerWikiUrl()).arg(qSlicerCoreApplication::application()->majorVersion()).arg(qSlicerCoreApplication::application()->minorVersion());
 }
 
 //-----------------------------------------------------------------------------