Merge branch 'rel_4.0'

Author: pyushkevich

.dockerignore

@@ -0,0 +1 @@
+#.git

CMakeLists.txt

@@ -90,12 +90,12 @@ ENDIF()
 # These four fields should be modified when versions change
 SET(SNAP_VERSION_MAJOR 4)
 SET(SNAP_VERSION_MINOR 0)
-SET(SNAP_VERSION_PATCH 0)
+SET(SNAP_VERSION_PATCH 1)
 SET(SNAP_VERSION_QUALIFIER "")
 
 # These fields should also be modified each time
-SET(SNAP_VERSION_RELEASE_DATE "20230220")
-SET(SNAP_VERSION_RELEASE_DATE_FORMATTED "February 20, 2023")
+SET(SNAP_VERSION_RELEASE_DATE "20230320")
+SET(SNAP_VERSION_RELEASE_DATE_FORMATTED "March 20, 2023")
 
 # This field should only change when the format of the settings files changes
 # in a non backwards-compatible way

GUI/Model/RegistrationModel.cxx

@@ -934,7 +934,7 @@ ::ResliceMovingImage(InterpolationMethod method)
   roi.SetInterpolationMethod(method);
   roi.SetROI(m_Driver->GetCurrentImageData()->GetMain()->GetBufferedRegion());
   SmartPtr<ImageWrapperBase> reslice =
-      moving->ExtractROI(roi, m_Parent->GetProgressCommand());
+      moving->ExtractROI4D(roi, m_Parent->GetProgressCommand());
 
   // Give it a nickname
   reslice->SetCustomNickname(std::string("resliced ") + moving->GetNickname());

GUI/Qt/Windows/InterpolateLabelsDialog.ui

@@ -163,7 +163,7 @@ color: gray;</string>
    <item>
     <widget class="QStackedWidget" name="stackedWidget">
      <property name="currentIndex">
-      <number>1</number>
+      <number>0</number>
      </property>
      <widget class="QWidget" name="morphoptions">
       <layout class="QVBoxLayout" name="verticalLayout_2">

GUI/Renderer/OrientationWidget/Reorient/AxesWidget.cxx

@@ -21,9 +21,14 @@ AxesWidget::AxesWidget()
   m_pvtkAxesActor->SetYAxisLabelText( "y" );
   m_pvtkAxesActor->SetZAxisLabelText( "z" );
 
+  // Turn off lighting to prevent normal flipping effect
+  m_pvtkAxesActor->GetXAxisShaftProperty()->SetLighting(false);
+  m_pvtkAxesActor->GetYAxisShaftProperty()->SetLighting(false);
+  m_pvtkAxesActor->GetZAxisShaftProperty()->SetLighting(false);
+
   m_pvtkAxesActor->SetTotalLength( 1.5, 1.5, 1.5 );
-  m_pvtkAxesActor->SetCylinderRadius( 0.500 * m_pvtkAxesActor->GetCylinderRadius() );
-  m_pvtkAxesActor->SetConeRadius    ( 1.025 * m_pvtkAxesActor->GetConeRadius() );
+  m_pvtkAxesActor->SetCylinderRadius( 0.250 * m_pvtkAxesActor->GetCylinderRadius() );
+  m_pvtkAxesActor->SetConeRadius    ( 0.750 * m_pvtkAxesActor->GetConeRadius() );
   m_pvtkAxesActor->SetSphereRadius  ( 1.500 * m_pvtkAxesActor->GetSphereRadius() );
 
   m_pvtkAxesActor->SetConeResolution(100);

GUI/Renderer/OrientationWidget/Reorient/PolyDataAlgorithm2ActorPipe.cxx

@@ -2,6 +2,7 @@
 #include <vtkObjectFactory.h>
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
+#include <vtkProperty.h>
 
 #include "PolyDataAlgorithm2ActorPipe.h"
 
@@ -13,6 +14,7 @@ PolyDataAlgorithm2ActorPipe::PolyDataAlgorithm2ActorPipe()
   m_pvtkPolyDataMapper = vtkSmartPointer < vtkPolyDataMapper >::New();
   m_pvtkActor = vtkSmartPointer < vtkActor >::New();
   m_pvtkActor->SetMapper(m_pvtkPolyDataMapper);
+  m_pvtkActor->GetProperty()->SetLighting(false);
 
 }
 

GUI/Renderer/OrientationWidget/Reorient/ScanningROI.cxx

@@ -159,71 +159,36 @@ void ScanningROI::setSpacing(double aarrdbXYZ[3])
 
 void ScanningROI::Update()
 {
+  m_pAxesWidget->GetAxesActor()->SetPosition(- m_dbGraphicScale / 2.0, -m_dbGraphicScale / 2.0, -m_dbGraphicScale / 2.0);
+  m_pAxesWidget->SetLabels("i", "j", "k");
+  m_pAxesWidget->SetColors(AxesWidget::m_arrdbColRed, AxesWidget::m_arrdbColGreen, AxesWidget::m_arrdbColBlue);
+  m_pAxesWidget->SetLengths(2.0 * m_dbGraphicScale);
 
-  vtkSmartPointer < vtkMatrix4x4 > pMatrix4x4DirectionsAccompanying =
-	  vtkSmartPointer < vtkMatrix4x4 >::New();
-  pMatrix4x4DirectionsAccompanying->Identity();
-
-  if(m_pMatrix4x4Directions->Determinant() > 0.0)
-    {
-    m_pAxesWidget->GetAxesActor()->SetPosition(- m_dbGraphicScale / 2.0, -m_dbGraphicScale / 2.0, -m_dbGraphicScale / 2.0);
-	m_pAxesWidget->SetLabels("i", "j", "k");
-    m_pAxesWidget->SetColors(AxesWidget::m_arrdbColRed, AxesWidget::m_arrdbColGreen, AxesWidget::m_arrdbColBlue);
-    }
-  else
-    {
-	//m_pAxesWidget->GetAxesActor()->SetPosition(m_dbGraphicScale / 2.0, m_dbGraphicScale / 2.0, m_dbGraphicScale / 2.0);
-	
-    pMatrix4x4DirectionsAccompanying->SetElement(0, 0, -1.0);
-    pMatrix4x4DirectionsAccompanying->SetElement(1, 1, 0.0);
-    pMatrix4x4DirectionsAccompanying->SetElement(1, 2, -1.0);
-    pMatrix4x4DirectionsAccompanying->SetElement(2, 1, -1.0);
-    pMatrix4x4DirectionsAccompanying->SetElement(2, 2, 0.0);
-
-	changeOrientation3x3(m_pMatrix4x4Directions);
-	m_pAxesWidget->SetLabels("i", "k", "j");
-    m_pAxesWidget->SetColors(AxesWidget::m_arrdbColRed, AxesWidget::m_arrdbColBlue, AxesWidget::m_arrdbColGreen);
-    }
-
-  m_pAxesWidget->GetAxesActor()->SetUserMatrix(pMatrix4x4DirectionsAccompanying);
-
-  //m_pMatrix4x4Directions->DeepCopy(apMatrix4x4);
-  //widget->GetProp3D()->SetUserTransform(t);
   vtkSmartPointer < vtkTransform > pTransform = vtkSmartPointer < vtkTransform >::New();
   pTransform->SetMatrix(m_pMatrix4x4Directions);
-  vtkLinearTransform *pLinearTransform = m_pvtkAssembly->GetUserTransform();
-  if(pLinearTransform == 0)
-    m_pvtkAssembly->SetUserTransform(pTransform);
-  else
-	pLinearTransform->DeepCopy(pTransform);
-
-  m_pAxesWidget->SetLengths(2.0 * m_dbGraphicScale);
+  m_pvtkAssembly->SetUserTransform(pTransform);
 
   int nI;
   int nPlanesNr = getPlanesNr();
   double dbDelta = m_dbGraphicScale / ((double)(nPlanesNr - 1));
   for(nI = 0; nI < nPlanesNr; nI++)
     {
     //First, create the transparent planes
-    double arrdbOrigin[4] = {0.0, 0.0, 0.0, 1.0},
-      arrdbP1[4] = {0.0, 0.0, 0.0, 1.0},
-	  arrdbP2[4] = {0.0, 0.0, 0.0, 1.0};
+    double arrdbOrigin[4] = {0.0, 0.0, 0.0, 1.0};
+    double arrdbP1[4] = {0.0, 0.0, 0.0, 1.0};
+    double arrdbP2[4] = {0.0, 0.0, 0.0, 1.0};
 
     arrdbOrigin[0] = - m_dbGraphicScale / 2.0;
-	arrdbOrigin[1] = - m_dbGraphicScale / 2.0;
+    arrdbOrigin[1] = - m_dbGraphicScale / 2.0;
     arrdbOrigin[2] = dbDelta * nI - ((int)(((double)nPlanesNr) / 2.0))  * dbDelta;
 
-	arrdbP1[0] = m_dbGraphicScale / 2.0;
-	arrdbP1[1] = - m_dbGraphicScale / 2.0;
-	arrdbP1[2] = arrdbOrigin[2];
-
-	arrdbP2[0] = - m_dbGraphicScale / 2.0;
-	arrdbP2[1] = m_dbGraphicScale / 2.0;
-	arrdbP2[2] = arrdbOrigin[2];
+    arrdbP1[0] = m_dbGraphicScale / 2.0;
+    arrdbP1[1] = - m_dbGraphicScale / 2.0;
+    arrdbP1[2] = arrdbOrigin[2];
 
-    //pMatrix4x4DirectionsAccompanying->MultiplyDoublePoint(arrdbOrigin);
-    //pMatrix4x4DirectionsAccompanying->MultiplyDoublePoint(arrdbP2);
-    //pMatrix4x4DirectionsAccompanying->MultiplyDoublePoint(arrdbP2);
+    arrdbP2[0] = - m_dbGraphicScale / 2.0;
+    arrdbP2[1] = m_dbGraphicScale / 2.0;
+    arrdbP2[2] = arrdbOrigin[2];
 
     Pairs_Plane_Pipe & ppp = m_arrpPairsPP_Axial[nI];
     vtkSmartPointer < vtkPlaneSource > pPlaneSource = ppp.m_p_PlaneSource;

GUI/Renderer/OrientationWidget/Reorient/ScanningROI.h

@@ -8,6 +8,7 @@ class vtkAssembly;
 class vtkPlaneSource;
 class vtkCaptionActor2D;
 class vtkTubeFilter;
+class vtkMatrix4x4;
 
 class AxesWidget;
 class PolyDataAlgorithm2ActorPipe;

Logic/ImageWrapper/ImageWrapper.cxx

@@ -74,6 +74,7 @@
 #include "AffineTransformHelper.h"
 #include "InputSelectionImageFilter.h"
 #include "MetaDataAccess.h"
+#include "AllPurposeProgressAccumulator.h"
 
 #include <vnl/vnl_inverse.h>
 #include <iostream>
@@ -2371,6 +2372,39 @@ ::ExtractROI(const SNAPSegmentationROISettings &roi,
   return retptr;
 }
 
+template<class TTraits, class TBase>
+SmartPtr<ImageWrapperBase>
+ImageWrapper<TTraits,TBase>
+::ExtractROI4D(const SNAPSegmentationROISettings &roi,
+             itk::Command *progressCommand) const
+{
+  Image4DPointer newImage = this->DeepCopyRegion4D(roi, progressCommand);
+
+  // Initialize the new wrapper
+  typedef typename TTraits::WrapperType WrapperType;
+  SmartPtr<WrapperType> newWrapper = WrapperType::New();
+
+  // Copy the display to anatomy geometry to the new wrapper
+  IRISDisplayGeometry temp = m_DisplayGeometry;
+  newWrapper->SetDisplayGeometry(temp);
+
+  // Assign the new image to the new wrapper
+  newWrapper->SetImage4D(newImage);
+  newWrapper->SetNativeMapping(this->GetNativeMapping());
+
+  // Appropriate the default nickname?
+  newWrapper->SetDefaultNickname(this->GetDefaultNickname());
+  newWrapper->SetAlpha(this->GetAlpha());
+  newWrapper->SetSticky(this->IsSticky());
+
+  // We should not copy the user-assigned metadata. It's up to the
+  // user what should propagate to the ROI
+
+  // Cast to base class
+  SmartPtr<ImageWrapperBase> retptr = newWrapper.GetPointer();
+  return retptr;
+}
+
 
 template<class TTraits, class TBase>
 typename ImageWrapper<TTraits,TBase>::ImagePointer
@@ -2391,6 +2425,85 @@ ::DeepCopyRegion(const SNAPSegmentationROISettings &roi,
         force_resampling, progressCommand);
 }
 
+template<class TTraits, class TBase>
+typename ImageWrapper<TTraits,TBase>::Image4DPointer
+ImageWrapper<TTraits,TBase>
+::DeepCopyRegion4D(const SNAPSegmentationROISettings &roi,
+                 itk::Command *progressCommand) const
+{
+  // If the image in this wrapper is not the same as the reference space,
+  // we must force resampling to occur
+  bool force_resampling = !this->IsSlicingOrthogonal();
+
+  Image4DPointer outImg = Image4DType::New();
+  const unsigned int nT = this->GetNumberOfTimePoints();
+
+  // Set the spacing, origin, direction for the last coordinate
+  auto spacing_4d = m_Image4D->GetSpacing();
+  auto origin_4d = m_Image4D->GetOrigin();
+  auto dir_4d = m_Image4D->GetDirection();
+  auto region_4d = m_Image4D->GetBufferedRegion();
+
+  // Create a 4d buffer
+  typedef typename Image4DType::PixelContainer::Element ElementType;
+  typedef typename Image4DType::PixelContainer::ElementIdentifier ElementIdType;
+  auto size_3d = roi.GetROI().GetSize();
+  auto nC = m_Image4D->GetNumberOfComponentsPerPixel();
+  ElementIdType buffer3dSize = size_3d[0] * size_3d[1] * size_3d[2] * nC;
+  ElementIdType buffer3dSizeInBytes = buffer3dSize * sizeof(ElementType);
+  ElementIdType buffer4dSize = buffer3dSize * nT;
+  ElementType *buffer4d = new ElementType[buffer4dSize];
+  ElementType *pCrntTPStart = buffer4d; // starting mem location of the current tp
+
+  typedef ImageWrapperPartialSpecializationTraits<ImageType, Image4DType> Specialization;
+
+  // Prepare progress accumulation
+  SmartPtr<AllPurposeProgressAccumulator> progress = AllPurposeProgressAccumulator::New();
+  progress->AddObserver(itk::ProgressEvent(), progressCommand);
+  typedef AllPurposeProgressAccumulator::CommandPointer CmdPtr;
+  std::vector<CmdPtr> TPCommand;
+
+  for (unsigned int t = 0u; t < nT; ++t)
+    {
+    TPCommand.push_back(progress->RegisterITKSourceViaCommand(1));
+    }
+
+  typename ImageType::Pointer tpResliced, tpImg;
+
+  for (unsigned int t = 0u; t < nT; ++t)
+    {
+    tpImg = this->GetImageByTimePoint(t);
+    tpResliced = Specialization::CopyRegion(tpImg, m_ReferenceSpace, this->GetITKTransform(),
+                                         roi, force_resampling, TPCommand[t]);
+
+    auto buffer3d = tpResliced->GetPixelContainer()->GetBufferPointer();
+    memcpy(pCrntTPStart, buffer3d, buffer3dSizeInBytes);
+    pCrntTPStart += buffer3dSize; // Increment pointer to next tp start
+    }
+
+  // use the last resliced tp image to configure the output origin/spacing/direction/region
+  // -- this only configures the first three dimensions
+  for (int j = 0; j < 3; ++j)
+    {
+    region_4d.SetIndex(j, tpResliced->GetBufferedRegion().GetIndex(j));
+    region_4d.SetSize(j, tpResliced->GetBufferedRegion().GetSize(j));
+    spacing_4d[j] = tpResliced->GetSpacing()[j];
+    origin_4d[j] = tpResliced->GetOrigin()[j];
+    for(unsigned int k = 0; k < 3; k++)
+      dir_4d(j,k) = tpResliced->GetDirection() (j,k);
+    }
+
+  outImg->SetRegions(region_4d);
+  outImg->SetSpacing(spacing_4d);
+  outImg->SetOrigin(origin_4d);
+  outImg->SetDirection(dir_4d);
+  outImg->SetNumberOfComponentsPerPixel(tpResliced->GetNumberOfComponentsPerPixel());
+
+  // set the constructed 4d buffer to output's pixel container
+  outImg->GetPixelContainer()->SetImportPointer(buffer4d, buffer4dSize, true);
+  return outImg;
+}
+
 
 
 

Logic/ImageWrapper/ImageWrapper.h

@@ -487,6 +487,13 @@ class ImageWrapper : public TBase
   virtual SmartPtr<ImageWrapperBase> ExtractROI(
       const SNAPSegmentationROISettings &roi, itk::Command *progressCommand) const ITK_OVERRIDE;
 
+  /**
+   * Extract a 3d region of interest from all time points in the image wrapper,
+   * as a new wrapper of the same type
+   */
+  virtual SmartPtr<ImageWrapperBase> ExtractROI4D(
+      const SNAPSegmentationROISettings &roi, itk::Command *progressCommand) const ITK_OVERRIDE;
+
 
   /**
    * This method is used to perform a deep copy of a region of this image 
@@ -496,6 +503,14 @@ class ImageWrapper : public TBase
   virtual ImagePointer DeepCopyRegion(const SNAPSegmentationROISettings &roi,
                               itk::Command *progressCommand = NULL) const;
 
+  /**
+   * This method is used to perform a deep copy of a 3D region of each time points
+   * of this image into another 4D image, potentially resampling the region to use a
+   * different voxel size
+   */
+  virtual Image4DPointer DeepCopyRegion4D(const SNAPSegmentationROISettings &roi,
+                              itk::Command *progressCommand = NULL) const;
+
 
   /**
    * Get an iterator for traversing the image.  The iterator is initialized