fattori_g/reg23Topograms
0
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

MapTransformToNewOrigin and CalcInternalTransformV3 moved to another file, ouside of scout processor

Browse Source
This commit is contained in:
Proton local user
2023-05-12 16:13:12 +02:00
parent 9a8faa0693
commit 6ad0344791
9 changed files with 377 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
reg23Topograms/itkDTRrecon/CMakeLists.txt
View File

@ -16,6 +16,7 @@ INCLUDE_DIRECTORIES(${GDCM_INCLUDE_DIRS})
SET(SRCS
itkImageProcessor.cpp
itkImageProcessorHelpers.cpp
vtkContourTopogramProjectionFilter.cxx
DRTMetaInformation.cpp
@ -23,6 +24,7 @@ SET(SRCS
SET(HDR
itkImageProcessor.h
itkImageProcessorHelpers.h
itkQtIterationUpdate.h
itkgSiddonJacobsRayCastInterpolateImageFunction.h
itkgSiddonJacobsRayCastInterpolateImageFunction.hxx

6
reg23Topograms/itkDTRrecon/autoreg/itkTwoProjectionImageRegistrationMethod.h
View File

@ -163,6 +163,10 @@ public:
itkSetObjectMacro(Transform2, TransformType);
itkGetConstObjectMacro(Transform2, TransformType);
/** Set/Get the IsocIECTransform. */
itkSetObjectMacro(IsocIECTransform, TransformType);
itkGetConstObjectMacro(IsocIECTransform, TransformType);
/** Set/Get the Interpolators. */
itkSetObjectMacro(Interpolator1, InterpolatorType);
itkSetObjectMacro(Interpolator2, InterpolatorType);
@ -248,6 +252,8 @@ private:
FixedImageConstPointer m_FixedImage1;
FixedImageConstPointer m_FixedImage2;
TransformPointer m_IsocIECTransform;
TransformPointer m_Transform1;
TransformPointer m_Transform2;
InterpolatorPointer m_Interpolator1;

9
reg23Topograms/itkDTRrecon/autoreg/itkTwoProjectionImageRegistrationMethod.hxx
View File

@ -38,6 +38,7 @@ TwoProjectionImageRegistrationMethod<TFixedImage, TMovingImage>::TwoProjectionIm
m_MovingImage = nullptr; // has to be provided by the user.
m_Transform1 = nullptr; // has to be provided by the user.
m_Transform2 = nullptr; // has to be provided by the user.
m_IsocIECTransform = nullptr;
m_TransformMetaInfo = nullptr; // has to be provided by the user.
m_Interpolator1 = nullptr; // has to be provided by the user.
m_Interpolator2 = nullptr; // has to be provided by the user.
@ -80,6 +81,7 @@ void TwoProjectionImageRegistrationMethod<TFixedImage, TMovingImage>::SetFixedIm
m_FixedImageRegionDefined2 = true;
}
/*
* Initialize by setting the interconnects between components.
*/
@ -119,7 +121,8 @@ void TwoProjectionImageRegistrationMethod<TFixedImage, TMovingImage>::Initialize
// Connect the transform to the Decorator.
auto* transformOutput = static_cast<TransformOutputType*>(this->ProcessObject::GetOutput(0));
transformOutput->Set(m_Transform1.GetPointer());
//transformOutput->Set(m_Transform1.GetPointer());
transformOutput->Set(m_IsocIECTransform.GetPointer());
if (!m_Interpolator1) {
itkExceptionMacro(<< "Interpolator1 is not present");
@ -147,6 +150,7 @@ void TwoProjectionImageRegistrationMethod<TFixedImage, TMovingImage>::Initialize
m_Metric->SetFixedImage2(m_FixedImage2);
m_Metric->SetTransform1(m_Transform1);
m_Metric->SetTransform2(m_Transform2);
m_Metric->SetIsocTransf(m_IsocIECTransform);
m_Metric->SetTransformMetaInfo(m_TransformMetaInfo);
m_Metric->SetFilter1(m_Filter1);
m_Metric->SetFilter2(m_Filter2);
@ -174,7 +178,8 @@ void TwoProjectionImageRegistrationMethod<TFixedImage, TMovingImage>::Initialize
m_Optimizer->SetScales(m_Metric->GetWeightings());
m_Optimizer->SetCostFunction(m_Metric);
m_InitialOptimizerParameters = m_Metric->GetParameters();
m_InitialOptimizerParameters =
m_Metric->GetParameters();
m_Optimizer->SetInitialPosition(m_InitialOptimizerParameters);
}

6
reg23Topograms/itkDTRrecon/autoreg/itkgTwoImageToOneImageMetric.h
View File

@ -169,6 +169,10 @@ public:
/** Get a pointer to the Transform2. */
itkGetConstObjectMacro(Transform2, TransformType);
itkSetObjectMacro(IsocTransf, TransformType);
itkGetObjectMacro(IsocTransf, TransformType);
/** Connect the Interpolator. */
itkSetObjectMacro(Interpolator1, InterpolatorType);
@ -261,6 +265,8 @@ protected:
mutable TransformPointer m_Transform1;
mutable TransformPointer m_Transform2;
mutable TransformPointer m_IsocTransf;
InterpolatorPointer m_Interpolator1;
InterpolatorPointer m_Interpolator2;

13
reg23Topograms/itkDTRrecon/autoreg/itkgTwoImageToOneImageMetric.hxx
View File

@ -55,7 +55,8 @@ bool gTwoImageToOneImageMetric<TFixedImage, TMovingImage>::SetTransformParameter
itkExceptionMacro(<< "Transform 2 has not been assigned");
}
auto transformParameters = m_Transform1->GetParameters();
//auto transformParameters = m_Transform1->GetParameters();
auto transformParameters = m_IsocTransf->GetParameters();
double TranslationAlongX = transformParameters[3];
double TranslationAlongY = transformParameters[4];
double TranslationAlongZ = transformParameters[5];
@ -106,6 +107,10 @@ bool gTwoImageToOneImageMetric<TFixedImage, TMovingImage>::SetTransformParameter
std::cout << " Rotation Along Z = " << RotationAlongZ / dtr << " deg" << std::endl;
std::cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
//HERE WE HAVE TO CALCULATE INTERNAL TRANSFORMS!!!
// GIOVANNI
transformParameters[0] = RotationAlongX;
transformParameters[1] = RotationAlongY;
transformParameters[2] = RotationAlongZ;
@ -281,10 +286,12 @@ itk::Optimizer::ScalesType gTwoImageToOneImageMetric<TFixedImage, TMovingImage>:
}
template <typename TFixedImage, typename TMovingImage>
typename gTwoImageToOneImageMetric<TFixedImage, TMovingImage>::ParametersType gTwoImageToOneImageMetric<TFixedImage, TMovingImage>::GetParameters() const
typename gTwoImageToOneImageMetric<TFixedImage, TMovingImage>::
ParametersType gTwoImageToOneImageMetric<TFixedImage, TMovingImage>::GetParameters() const
{
ParametersType parametersTransform = m_Transform1->GetParameters(); //angleX, angleY, angleZ, transX, transY, transZ
// ParametersType parametersTransform = m_Transform1->GetParameters(); //angleX, angleY, angleZ, transX, transY, transZ
ParametersType parametersTransform = m_IsocTransf->GetParameters(); //angleX, angleY, angleZ, transX, transY, transZ
ParametersType parameters(this->GetNumberOfParameters());
switch (m_TransformMetaInfo->GetDegreeOfFreedom()) {
case X_ONLY:

377
reg23Topograms/itkDTRrecon/itkImageProcessor.cpp
View File

@ -1281,64 +1281,63 @@ double itkImageProcessor::GetLocalizerDisplayWindowWidth(int iImg)
}
itkImageProcessor::TransformType::Pointer
itkImageProcessor::MapTransformToNewOrigin(
ImageType3D::PointType m_COR, // Center of rotation for the proj geometry. this is my new origin.
ImageType3D::PointType m_Translations,
ImageType3D::PointType m_Rotations
){
//itkImageProcessor::TransformType::Pointer
//itkImageProcessor::MapTransformToNewOrigin(
// ImageType3D::PointType m_COR, // Center of rotation for the proj geometry. this is my new origin.
// ImageType3D::PointType m_Translations,
// ImageType3D::PointType m_Rotations
// ){
TransformType::Pointer InputTransform = TransformType::New();
InputTransform->SetComputeZYX(true);
InputTransform->SetIdentity();
// TransformType::Pointer InputTransform = TransformType::New();
// InputTransform->SetComputeZYX(true);
// InputTransform->SetIdentity();
TransformType::OutputVectorType translation;
translation[0] = m_Translations[0];
translation[1] = m_Translations[1];
translation[2] = m_Translations[2];
// TransformType::OutputVectorType translation;
// translation[0] = m_Translations[0];
// translation[1] = m_Translations[1];
// translation[2] = m_Translations[2];
InputTransform->SetTranslation(translation);
// InputTransform->SetTranslation(translation);
const double dtr = (atan(1.0) * 4.0) / 180.0;
InputTransform->SetRotation(
dtr * m_Rotations[0],
dtr * m_Rotations[1],
dtr * m_Rotations[2]);
// const double dtr = (atan(1.0) * 4.0) / 180.0;
// InputTransform->SetRotation(
// dtr * m_Rotations[0],
// dtr * m_Rotations[1],
// dtr * m_Rotations[2]);
ImageType3D::PointType m_TransformOrigin;
m_TransformOrigin.Fill(0.);
InputTransform->SetCenter(
m_TransformOrigin );
// ImageType3D::PointType m_TransformOrigin;
// m_TransformOrigin.Fill(0.);
// InputTransform->SetCenter(
// m_TransformOrigin );
ImageType3D::PointType NewOriginTranslations =
InputTransform->TransformPoint(m_COR);
// ImageType3D::PointType NewOriginTranslations =
// InputTransform->TransformPoint(m_COR);
ImageType3D::PointType DeltaNewOrigin =
NewOriginTranslations - m_COR;
// ImageType3D::PointType DeltaNewOrigin =
// NewOriginTranslations - m_COR;
TransformType::Pointer m_OutputTransform =
TransformType::New();
m_OutputTransform ->SetComputeZYX(true);
m_OutputTransform ->SetIdentity();
// TransformType::Pointer m_OutputTransform =
// TransformType::New();
// m_OutputTransform ->SetComputeZYX(true);
// m_OutputTransform ->SetIdentity();
translation[0] = DeltaNewOrigin[0];
translation[1] = DeltaNewOrigin[1];
translation[2] = DeltaNewOrigin[2];
// translation[0] = DeltaNewOrigin[0];
// translation[1] = DeltaNewOrigin[1];
// translation[2] = DeltaNewOrigin[2];
m_OutputTransform->SetTranslation(translation);
m_OutputTransform->SetRotation(
dtr * m_Rotations[0],
dtr * m_Rotations[1],
dtr * m_Rotations[2]);
// m_OutputTransform->SetTranslation(translation);
// m_OutputTransform->SetRotation(
// dtr * m_Rotations[0],
// dtr * m_Rotations[1],
// dtr * m_Rotations[2]);
m_OutputTransform->SetCenter(m_COR);
// m_OutputTransform->SetCenter(m_COR);
InputTransform = NULL;
// InputTransform = NULL;
// m_OutputTransform.Print(std::cout);
return m_OutputTransform;
}
// return m_OutputTransform;
//}
// This External User Transform thing need to be checked out
@ -1369,88 +1368,88 @@ void itkImageProcessor::CalculateExternalUserTransform(TransformType::Pointer tr
}
itkImageProcessor::TransformType::Pointer
itkImageProcessor::CalculateInternalTransformV2(
ImageType3D::PointType m_TranslationOffset, //IEC
ImageType3D::PointType m_RotationOffset, //IEC
ImageType3D::PointType m_TranslationUser, //IEC
ImageType3D::PointType m_RotationUser, //IEC
ImageType3D::PointType m_CalibratedProjectionCenter, //LPS
ImageType3D::PointType m_RTIsocenter, //LPS
InternalImageType::DirectionType m_IECtoLPSDirections
)
{
//itkImageProcessor::TransformType::Pointer
//itkImageProcessor::CalculateInternalTransformV2(
// ImageType3D::PointType m_TranslationOffset, //IEC
// ImageType3D::PointType m_RotationOffset, //IEC
// ImageType3D::PointType m_TranslationUser, //IEC
// ImageType3D::PointType m_RotationUser, //IEC
// ImageType3D::PointType m_CalibratedProjectionCenter, //LPS
// ImageType3D::PointType m_RTIsocenter, //LPS
// InternalImageType::DirectionType m_IECtoLPSDirections
// )
//{
//Convert all inputs into LPS
// //Convert all inputs into LPS
ImageType3D::PointType m_TOffsetLPS =
m_IECtoLPSDirections * m_TranslationOffset;
// ImageType3D::PointType m_TOffsetLPS =
// m_IECtoLPSDirections * m_TranslationOffset;
ImageType3D::PointType m_ROffsetLPS =
m_IECtoLPSDirections * m_RotationOffset;
// ImageType3D::PointType m_ROffsetLPS =
// m_IECtoLPSDirections * m_RotationOffset;
ImageType3D::PointType m_TUserLPS =
m_IECtoLPSDirections * m_TranslationUser;
// ImageType3D::PointType m_TUserLPS =
// m_IECtoLPSDirections * m_TranslationUser;
ImageType3D::PointType m_RUserLPS =
m_IECtoLPSDirections * m_RotationUser;
// ImageType3D::PointType m_RUserLPS =
// m_IECtoLPSDirections * m_RotationUser;
TransformType::OutputVectorType translation;
translation[0] = m_TOffsetLPS[0] + m_TUserLPS[0];
translation[1] = m_TOffsetLPS[1] + m_TUserLPS[1];
translation[2] = m_TOffsetLPS[2] + m_TUserLPS[2];
// TransformType::OutputVectorType translation;
// translation[0] = m_TOffsetLPS[0] + m_TUserLPS[0];
// translation[1] = m_TOffsetLPS[1] + m_TUserLPS[1];
// translation[2] = m_TOffsetLPS[2] + m_TUserLPS[2];
TransformType::OutputVectorType rotations;
rotations[0] = m_ROffsetLPS[0] + m_RUserLPS[0];
rotations[1] = m_ROffsetLPS[1] + m_RUserLPS[1];
rotations[2] = m_ROffsetLPS[2] + m_RUserLPS[2];
// TransformType::OutputVectorType rotations;
// rotations[0] = m_ROffsetLPS[0] + m_RUserLPS[0];
// rotations[1] = m_ROffsetLPS[1] + m_RUserLPS[1];
// rotations[2] = m_ROffsetLPS[2] + m_RUserLPS[2];
// Map offset to the projection center
TransformType::Pointer m_outputTransform =
MapTransformToNewOrigin (
m_CalibratedProjectionCenter - m_RTIsocenter,
translation,
rotations
);
// // Map offset to the projection center
// TransformType::Pointer m_outputTransform =
// MapTransformToNewOrigin (
// m_CalibratedProjectionCenter - m_RTIsocenter,
// translation,
// rotations
// );
m_outputTransform->SetCenter(m_CalibratedProjectionCenter);
// m_outputTransform->SetCenter(m_CalibratedProjectionCenter);
return m_outputTransform;
// return m_outputTransform;
}
//}
itkImageProcessor::TransformType::Pointer
itkImageProcessor::CalculateInternalTransformV3(
ImageType3D::PointType m_Translation, //IEC
ImageType3D::PointType m_Rotation, //IEC
ImageType3D::PointType m_CalibratedProjectionCenter, //LPS
ImageType3D::PointType m_RTIsocenter, //LPS
InternalImageType::DirectionType m_IECtoLPSDirections
)
{
//itkImageProcessor::TransformType::Pointer
//itkImageProcessor::CalculateInternalTransformV3(
// ImageType3D::PointType m_Translation, //IEC
// ImageType3D::PointType m_Rotation, //IEC
// ImageType3D::PointType m_CalibratedProjectionCenter, //LPS
// ImageType3D::PointType m_RTIsocenter, //LPS
// InternalImageType::DirectionType m_IECtoLPSDirections
// )
//{
//Convert all inputs into LPS
// //Convert all inputs into LPS
ImageType3D::PointType m_TLPS =
m_IECtoLPSDirections * m_Translation;
// ImageType3D::PointType m_TLPS =
// m_IECtoLPSDirections * m_Translation;
ImageType3D::PointType m_RLPS =
m_IECtoLPSDirections * m_Rotation;
// ImageType3D::PointType m_RLPS =
// m_IECtoLPSDirections * m_Rotation;
// Map offset to the projection center
TransformType::Pointer m_outputTransform =
MapTransformToNewOrigin (
m_CalibratedProjectionCenter - m_RTIsocenter,
m_TLPS,
m_RLPS
);
// // Map offset to the projection center
// TransformType::Pointer m_outputTransform =
// MapTransformToNewOrigin (
// m_CalibratedProjectionCenter - m_RTIsocenter,
// m_TLPS,
// m_RLPS
// );
m_outputTransform->SetCenter(m_CalibratedProjectionCenter);
// m_outputTransform->SetCenter(m_CalibratedProjectionCenter);
return m_outputTransform;
// return m_outputTransform;
}
//}
void itkImageProcessor::InitializeRegistration(
@ -1528,94 +1527,109 @@ void itkImageProcessor::InitializeRegistration(
//CalculateInternalTransform(transform1, m_DRTImage1MetaInfo);
/********* BEGIN CALCULATION OF INTERNAL TRANSFORM FOR PROJ1 *********/
ImageType3D::PointType ZeroPoint;
ZeroPoint.Fill(0.);
InternalImageType::DirectionType IECtoLPS_Directions;
IECtoLPS_Directions =
m_CTMetaInfo->GetLPS2IECDirections().GetTranspose();
TransformType::Pointer CurrTransform;
if(m_RTMetaInfo == NULL)
{
CurrTransform =
CalculateInternalTransformV3(
m_TransformMetaInfo->GetT(),
m_TransformMetaInfo->GetR(),
m_DRTImage1MetaInfo->GetProjectionOriginLPSZero(),
m_DRTImage1MetaInfo->GetProjectionOriginLPS(),
IECtoLPS_Directions);
// ImageType3D::PointType ZeroPoint;
// ZeroPoint.Fill(0.);
// InternalImageType::DirectionType IECtoLPS_Directions;
// IECtoLPS_Directions =
// m_CTMetaInfo->GetLPS2IECDirections().GetTranspose();
// TransformType::Pointer CurrTransform;
// if(m_RTMetaInfo == NULL)
// {
// CurrTransform =
// CalculateInternalTransformV3(
// m_TransformMetaInfo->GetT(),
// m_TransformMetaInfo->GetR(),
// m_DRTImage1MetaInfo->GetProjectionOriginLPSZero(),
// m_DRTImage1MetaInfo->GetProjectionOriginLPS(),
// IECtoLPS_Directions);
} else {
// } else {
CurrTransform =
CalculateInternalTransformV3(
m_TransformMetaInfo->GetT(),
m_TransformMetaInfo->GetR(),
m_DRTImage1MetaInfo->GetProjectionOriginLPSZero(),
m_RTMetaInfo->GetIsocenterLPS() - m_CTMetaInfo->GetOriginLPS(),
IECtoLPS_Directions
);
// CurrTransform =
// CalculateInternalTransformV3(
// m_TransformMetaInfo->GetT(),
// m_TransformMetaInfo->GetR(),
// m_DRTImage1MetaInfo->GetProjectionOriginLPSZero(),
// m_RTMetaInfo->GetIsocenterLPS() - m_CTMetaInfo->GetOriginLPS(),
// IECtoLPS_Directions
// );
}
// }
transform1->SetComputeZYX(true);
transform1->SetIdentity();
transform1->SetTranslation(
CurrTransform->GetTranslation());
transform1->SetRotation(
CurrTransform->GetAngleX(),
CurrTransform->GetAngleY(),
CurrTransform->GetAngleZ()
);
transform1->SetCenter(
m_DRTImage1MetaInfo->GetProjectionOriginLPSZero() );
// transform1->SetComputeZYX(true);
// transform1->SetIdentity();
// transform1->SetTranslation(
// CurrTransform->GetTranslation());
// transform1->SetRotation(
// CurrTransform->GetAngleX(),
// CurrTransform->GetAngleY(),
// CurrTransform->GetAngleZ()
// );
// transform1->SetCenter(
// m_DRTImage1MetaInfo->GetProjectionOriginLPSZero() );
// /********* END OF CALCULATE INTERNAL TRANSFORM FOR PROJ1 *********/
// //CalculateInternalTransform(transform2, m_DRTImage2MetaInfo);
// /********* BEGIN CALCULATION OF INTERNAL TRANSFORM FOR PROJ2 *********/
// if(m_RTMetaInfo == NULL)
// {
// CurrTransform =
// CalculateInternalTransformV3(
// m_TransformMetaInfo->GetT(),
// m_TransformMetaInfo->GetR(),
// m_DRTImage2MetaInfo->GetProjectionOriginLPSZero(),
// m_DRTImage2MetaInfo->GetProjectionOriginLPS(),
// IECtoLPS_Directions);
// } else {
// CurrTransform =
// CalculateInternalTransformV3(
// m_TransformMetaInfo->GetT(),
// m_TransformMetaInfo->GetR(),
// m_DRTImage2MetaInfo->GetProjectionOriginLPSZero(),
// m_RTMetaInfo->GetIsocenterLPS() - m_CTMetaInfo->GetOriginLPS(),
// IECtoLPS_Directions
// );
// }
// transform2->SetComputeZYX(true);
// transform2->SetIdentity();
// transform2->SetTranslation(
// CurrTransform->GetTranslation());
// transform2->SetRotation(
// CurrTransform->GetAngleX(),
// CurrTransform->GetAngleY(),
// CurrTransform->GetAngleZ()
// );
// transform2->SetCenter(
// m_DRTImage2MetaInfo->GetProjectionOriginLPSZero() );
/********* END OF CALCULATE INTERNAL TRANSFORM FOR PROJ1 *********/
IsocTransf = TransformType::New();
IsocTransf->SetRotation(
m_TransformMetaInfo->GetR()[0],
m_TransformMetaInfo->GetR()[1],
m_TransformMetaInfo->GetR()[2]
);
//CalculateInternalTransform(transform2, m_DRTImage2MetaInfo);
/********* BEGIN CALCULATION OF INTERNAL TRANSFORM FOR PROJ2 *********/
if(m_RTMetaInfo == NULL)
{
CurrTransform =
CalculateInternalTransformV3(
m_TransformMetaInfo->GetT(),
m_TransformMetaInfo->GetR(),
m_DRTImage2MetaInfo->GetProjectionOriginLPSZero(),
m_DRTImage2MetaInfo->GetProjectionOriginLPS(),
IECtoLPS_Directions);
TransformType::OutputVectorType TranslV;
TranslV[0] = m_TransformMetaInfo->GetT()[0];
TranslV[1] = m_TransformMetaInfo->GetT()[1];
TranslV[2] = m_TransformMetaInfo->GetT()[2];
IsocTransf->SetTranslation(TranslV);
} else {
CurrTransform =
CalculateInternalTransformV3(
m_TransformMetaInfo->GetT(),
m_TransformMetaInfo->GetR(),
m_DRTImage2MetaInfo->GetProjectionOriginLPSZero(),
m_RTMetaInfo->GetIsocenterLPS() - m_CTMetaInfo->GetOriginLPS(),
IECtoLPS_Directions
);
}
transform2->SetComputeZYX(true);
transform2->SetIdentity();
transform2->SetTranslation(
CurrTransform->GetTranslation());
transform2->SetRotation(
CurrTransform->GetAngleX(),
CurrTransform->GetAngleY(),
CurrTransform->GetAngleZ()
);
transform2->SetCenter(
m_DRTImage2MetaInfo->GetProjectionOriginLPSZero() );
/********* END OF CALCULATE INTERNAL TRANSFORM FOR PROJ1 *********/
registration->SetIsocIECTransform(IsocTransf);
if (verbose) {
registration->DebugOn();
@ -2055,8 +2069,7 @@ int itkImageProcessor::unloadRTPlanAndMeta(){
std::cout << "*" << __COMPACT_PRETTY_FUNCTION__ << std::endl;
m_RTMetaInfo = NULL;
ImageType3D::PointType
pZero;
ImageType3D::PointType pZero;
pZero.Fill(0.);
m_CTMetaInfo->SetImportOffset(pZero);

45
reg23Topograms/itkDTRrecon/itkImageProcessor.h
View File

@ -51,6 +51,8 @@ gfattori 08.11.2021
#include "itkQtIterationUpdate.h"
#include "itkImageProcessorHelpers.h"
namespace itk
{
@ -271,29 +273,22 @@ private:
/* Calculate the transform used in siddon.
* The isocentric transform is mapped to the calibrated center of projection */
TransformType::Pointer
CalculateInternalTransformV2(
ImageType3D::PointType m_TranslationOffset,
ImageType3D::PointType m_RotationOffset,
ImageType3D::PointType m_TranslationUser,
ImageType3D::PointType m_RotationUser,
ImageType3D::PointType m_CalibratedProjectionCenter,
ImageType3D::PointType m_RTIsocenter,
InternalImageType::DirectionType m_IECtoLPSDirections
);
// TransformType::Pointer
// CalculateInternalTransformV2(
// ImageType3D::PointType m_TranslationOffset,
// ImageType3D::PointType m_RotationOffset,
// ImageType3D::PointType m_TranslationUser,
// ImageType3D::PointType m_RotationUser,
// ImageType3D::PointType m_CalibratedProjectionCenter,
// ImageType3D::PointType m_RTIsocenter,
// InternalImageType::DirectionType m_IECtoLPSDirections
// );
TransformType::Pointer
CalculateInternalTransformV3(
ImageType3D::PointType m_Translation,
ImageType3D::PointType m_Rotation,
ImageType3D::PointType m_CalibratedProjectionCenter,
ImageType3D::PointType m_RTIsocenter,
InternalImageType::DirectionType m_IECtoLPSDirections
);
TransformType::Pointer
transform1,
transform2;
transform2,
IsocTransf;
InterpolatorType::Pointer
interpolator1,
@ -355,12 +350,12 @@ private:
);
TransformType::Pointer
MapTransformToNewOrigin(
ImageType3D::PointType m_COR,
ImageType3D::PointType m_Translations,
ImageType3D::PointType m_Rotations
);
// TransformType::Pointer
// MapTransformToNewOrigin(
// ImageType3D::PointType m_COR,
// ImageType3D::PointType m_Translations,
// ImageType3D::PointType m_Rotations
// );
double
CalcProjectionAngleLPS(

93
reg23Topograms/itkDTRrecon/itkImageProcessorHelpers.cpp Normal file
View File

@ -0,0 +1,93 @@
#include "itkImageProcessorHelpers.h"
itk::TransformType::Pointer
itk::MapTransformToNewOrigin(
ImageType3D::PointType m_COR, // Center of rotation for the proj geometry. this is my new origin.
ImageType3D::PointType m_Translations,
ImageType3D::PointType m_Rotations
){
TransformType::Pointer InputTransform = TransformType::New();
InputTransform->SetComputeZYX(true);
InputTransform->SetIdentity();
TransformType::OutputVectorType translation;
translation[0] = m_Translations[0];
translation[1] = m_Translations[1];
translation[2] = m_Translations[2];
InputTransform->SetTranslation(translation);
const double dtr = (atan(1.0) * 4.0) / 180.0;
InputTransform->SetRotation(
dtr * m_Rotations[0],
dtr * m_Rotations[1],
dtr * m_Rotations[2]);
ImageType3D::PointType m_TransformOrigin;
m_TransformOrigin.Fill(0.);
InputTransform->SetCenter(
m_TransformOrigin );
ImageType3D::PointType NewOriginTranslations =
InputTransform->TransformPoint(m_COR);
ImageType3D::PointType DeltaNewOrigin =
NewOriginTranslations - m_COR;
TransformType::Pointer m_OutputTransform =
TransformType::New();
m_OutputTransform ->SetComputeZYX(true);
m_OutputTransform ->SetIdentity();
translation[0] = DeltaNewOrigin[0];
translation[1] = DeltaNewOrigin[1];
translation[2] = DeltaNewOrigin[2];
m_OutputTransform->SetTranslation(translation);
m_OutputTransform->SetRotation(
dtr * m_Rotations[0],
dtr * m_Rotations[1],
dtr * m_Rotations[2]);
m_OutputTransform->SetCenter(m_COR);
InputTransform = NULL;
return m_OutputTransform;
}
itk::TransformType::Pointer
itk::CalculateInternalTransformV3(
ImageType3D::PointType m_Translation, //IEC
ImageType3D::PointType m_Rotation, //IEC
ImageType3D::PointType m_CalibratedProjectionCenter, //LPS
ImageType3D::PointType m_RTIsocenter, //LPS
InternalImageType::DirectionType m_IECtoLPSDirections
)
{
//Convert all inputs into LPS
ImageType3D::PointType m_TLPS =
m_IECtoLPSDirections * m_Translation;
ImageType3D::PointType m_RLPS =
m_IECtoLPSDirections * m_Rotation;
// Map offset to the projection center
TransformType::Pointer m_outputTransform =
MapTransformToNewOrigin (
m_CalibratedProjectionCenter - m_RTIsocenter,
m_TLPS,
m_RLPS
);
m_outputTransform->SetCenter(m_CalibratedProjectionCenter);
return m_outputTransform;
}

38
reg23Topograms/itkDTRrecon/itkImageProcessorHelpers.h Normal file
View File

@ -0,0 +1,38 @@
#ifndef ITKIMAGEPROCESSORHELPERS_H
#define ITKIMAGEPROCESSORHELPERS_H
#include "itkEuler3DTransform.h"
#include "itkImage.h"
namespace itk
{
constexpr static unsigned int Dimension = 3;
using PixelType3D = short;
using InternalPixelType = float;
using ImageType3D = itk::Image<PixelType3D, Dimension>;
using InternalImageType = itk::Image<InternalPixelType, Dimension>;
using TransformType = itk::Euler3DTransform<double>;
TransformType::Pointer
MapTransformToNewOrigin(
ImageType3D::PointType m_COR,
ImageType3D::PointType m_Translations,
ImageType3D::PointType m_Rotations
);
TransformType::Pointer
CalculateInternalTransformV3(
ImageType3D::PointType m_Translation,
ImageType3D::PointType m_Rotation,
ImageType3D::PointType m_CalibratedProjectionCenter,
ImageType3D::PointType m_RTIsocenter,
InternalImageType::DirectionType m_IECtoLPSDirections
);
}
#endif