diff --git a/Modules/Core/Common/include/itkAnatomicalOrientation.h b/Modules/Core/Common/include/itkAnatomicalOrientation.h index d77cbf80968..8575dab398a 100644 --- a/Modules/Core/Common/include/itkAnatomicalOrientation.h +++ b/Modules/Core/Common/include/itkAnatomicalOrientation.h @@ -62,7 +62,7 @@ class ITKCommon_EXPORT AnatomicalOrientation SuperiorToInferior = 9, ///< foot }; -private: +protected: enum class CoordinateMajornessTermsEnum : uint8_t { PrimaryMinor = 0, @@ -80,7 +80,7 @@ class ITKCommon_EXPORT AnatomicalOrientation GetCoordinateTerm(CoordinateMajornessTermsEnum cmt) const; public: - enum class ToEnum : uint32_t + enum class PositiveEnum : uint32_t { INVALID = 0, @@ -236,7 +236,7 @@ class ITKCommon_EXPORT AnatomicalOrientation CoordinateEnum::RightToLeft> }; - enum class FromEnum : uint32_t + enum class NegativeEnum : uint32_t { INVALID = 0, @@ -400,7 +400,7 @@ class ITKCommon_EXPORT AnatomicalOrientation */ AnatomicalOrientation(CoordinateEnum primary, CoordinateEnum secondary, CoordinateEnum tertiary); - AnatomicalOrientation(ToEnum orientation) + AnatomicalOrientation(PositiveEnum orientation) : m_Value(orientation) {} @@ -416,30 +416,33 @@ class ITKCommon_EXPORT AnatomicalOrientation AnatomicalOrientation(LegacyOrientationType legacyOrientation); #endif - AnatomicalOrientation(FromEnum orientation); + AnatomicalOrientation(NegativeEnum orientation); explicit AnatomicalOrientation(const DirectionType & d) - : m_Value(DirectionCosinesToOrientation(d)) + : m_Value(ConvertDirectionToPositiveEnum(d)) {} - operator ToEnum() const { return m_Value; } + static AnatomicalOrientation + CreateFromPositiveStringEncoding(const std::string & str); - std::string - GetAsToStringEncoding() const; + static AnatomicalOrientation + CreateFromNegativeStringEncoding(const std::string & str); - std::string - GetAsFromStringEncoding() const; + operator PositiveEnum() const { return m_Value; } - static AnatomicalOrientation - CreateFromToStringEncoding(std::string str); - static AnatomicalOrientation - CreateFromFromStringEncoding(std::string str); + std::string + GetAsPositiveStringEncoding() const; + + std::string + GetAsNegativeStringEncoding() const; - /** An involution to convert between "to" and "from" single character encoding strings. + /** An involution to convert between "positive" and "negative" single character encoding strings. * * For example the string "RAS" is converted to "LPI" and vice versa. * + * The input maybe upper or lower case, while the output is always upper case. + * There is not check that the input is a valid encoding. * * */ static std::string @@ -448,15 +451,21 @@ class ITKCommon_EXPORT AnatomicalOrientation DirectionType GetAsDirection() const { - return OrientationToDirectionCosines(m_Value); + return ConvertPositiveEnumToDirection(m_Value); } - ToEnum - GetAsOrientation() const + PositiveEnum + GetAsPositiveOrientation() const { return m_Value; } + NegativeEnum + GetAsNegativeOrientation() const + { + return NegativeEnum(uint32_t(this->m_Value)); + } + CoordinateEnum GetPrimaryTerm() const { @@ -488,34 +497,33 @@ class ITKCommon_EXPORT AnatomicalOrientation return (static_cast(a) & AxisField) == (static_cast(b) & AxisField); } - /** \brief Return the closest orientation for a direction cosine matrix. */ - static ToEnum - DirectionCosinesToOrientation(const DirectionType & dir); - /** \brief Return the direction cosine matrix for a orientation. */ - static DirectionType OrientationToDirectionCosines(ToEnum); + friend ITKCommon_EXPORT std::ostream & + operator<<(std::ostream & out, PositiveEnum value); +protected: + /** \brief Return the direction cosine matrix for a orientation. */ + static DirectionType ConvertPositiveEnumToDirection(PositiveEnum); - friend ITKCommon_EXPORT std::ostream & - operator<<(std::ostream & out, ToEnum value); + /** \brief Return the closest orientation for a direction cosine matrix. */ + static PositiveEnum + ConvertDirectionToPositiveEnum(const DirectionType & dir); -private: - // Private methods to create the maps, these will only be called once. /** \brief Return the global instance of the map from orientation enum to strings. * * The implementation uses a function static local variable so the global is created only if needed, only once. */ - static const std::map & + static const std::map & GetCodeToString(); /** \brief Return the global instance of the map from string to orientation enum. */ - static const std::map & + static const std::map & GetStringToCode(); - ToEnum m_Value; + PositiveEnum m_Value; }; @@ -523,7 +531,7 @@ ITKCommon_EXPORT std::ostream & operator<<(std::ostream & out, typename AnatomicalOrientation::CoordinateEnum value); ITKCommon_EXPORT std::ostream & - operator<<(std::ostream & out, typename AnatomicalOrientation::ToEnum value); + operator<<(std::ostream & out, typename AnatomicalOrientation::PositiveEnum value); ITKCommon_EXPORT std::ostream & operator<<(std::ostream & out, const AnatomicalOrientation & orientation); diff --git a/Modules/Core/Common/src/itkAnatomicalOrientation.cxx b/Modules/Core/Common/src/itkAnatomicalOrientation.cxx index 68f4354c08b..c996f5b24a4 100644 --- a/Modules/Core/Common/src/itkAnatomicalOrientation.cxx +++ b/Modules/Core/Common/src/itkAnatomicalOrientation.cxx @@ -29,11 +29,11 @@ AnatomicalOrientation::AnatomicalOrientation(CoordinateEnum primary, CoordinateE if (SameOrientationAxes(primary, secondary) || SameOrientationAxes(primary, tertiary) || SameOrientationAxes(secondary, tertiary)) { - m_Value = ToEnum::INVALID; + m_Value = PositiveEnum::INVALID; } else { - m_Value = static_cast( + m_Value = static_cast( (static_cast(primary) << static_cast(CoordinateMajornessTermsEnum::PrimaryMinor)) + (static_cast(secondary) << static_cast(CoordinateMajornessTermsEnum::SecondaryMinor)) + (static_cast(tertiary) << static_cast(CoordinateMajornessTermsEnum::TertiaryMinor))); @@ -48,13 +48,13 @@ AnatomicalOrientation::AnatomicalOrientation(LegacyOrientationType legacyOrienta } #endif -AnatomicalOrientation::AnatomicalOrientation(AnatomicalOrientation::FromEnum fromOrientation) - : m_Value(ToEnum(uint32_t(fromOrientation))) +AnatomicalOrientation::AnatomicalOrientation(AnatomicalOrientation::NegativeEnum fromOrientation) + : m_Value(PositiveEnum(uint32_t(fromOrientation))) {} std::string -AnatomicalOrientation::GetAsToStringEncoding() const +AnatomicalOrientation::GetAsPositiveStringEncoding() const { // a lambda function to convert a CoordinateEnum to a char @@ -78,7 +78,7 @@ AnatomicalOrientation::GetAsToStringEncoding() const } }; - if (m_Value == ToEnum::INVALID) + if (m_Value == PositiveEnum::INVALID) { return "INVALID"; } @@ -88,30 +88,30 @@ AnatomicalOrientation::GetAsToStringEncoding() const std::string -AnatomicalOrientation::GetAsFromStringEncoding() const +AnatomicalOrientation::GetAsNegativeStringEncoding() const { - return ConvertStringEncoding(GetAsToStringEncoding()); + return ConvertStringEncoding(GetAsPositiveStringEncoding()); } AnatomicalOrientation -AnatomicalOrientation::CreateFromToStringEncoding(std::string str) +AnatomicalOrientation::CreateFromPositiveStringEncoding(const std::string & str) { std::transform(str.begin(), str.end(), str.begin(), ::toupper); - const std::map & stringToCode = GetStringToCode(); - auto iter = stringToCode.find(str); + const std::map & stringToCode = GetStringToCode(); + auto iter = stringToCode.find(str); if (iter == stringToCode.end()) { - return AnatomicalOrientation(ToEnum::INVALID); + return AnatomicalOrientation(PositiveEnum::INVALID); } return AnatomicalOrientation(iter->second); } AnatomicalOrientation -AnatomicalOrientation::CreateFromFromStringEncoding(std::string str) +AnatomicalOrientation::CreateFromNegativeStringEncoding(const std::string & str) { - return AnatomicalOrientation::CreateFromToStringEncoding(ConvertStringEncoding(str)); + return AnatomicalOrientation::CreateFromPositiveStringEncoding(ConvertStringEncoding(str)); } @@ -156,36 +156,39 @@ AnatomicalOrientation::GetCoordinateTerm(CoordinateMajornessTermsEnum cmt) const } -const std::map & +const std::map & AnatomicalOrientation::GetCodeToString() { - auto createCodeToString = []() -> std::map { - std::map orientToString; - - for (auto code : { ToEnum::RIP, ToEnum::LIP, ToEnum::RSP, ToEnum::LSP, ToEnum::RIA, ToEnum::LIA, ToEnum::RSA, - ToEnum::LSA, ToEnum::IRP, ToEnum::ILP, ToEnum::SRP, ToEnum::SLP, ToEnum::IRA, ToEnum::ILA, - ToEnum::SRA, ToEnum::SLA, ToEnum::RPI, ToEnum::LPI, ToEnum::RAI, ToEnum::LAI, ToEnum::RPS, - ToEnum::LPS, ToEnum::RAS, ToEnum::LAS, ToEnum::PRI, ToEnum::PLI, ToEnum::ARI, ToEnum::ALI, - ToEnum::PRS, ToEnum::PLS, ToEnum::ARS, ToEnum::ALS, ToEnum::IPR, ToEnum::SPR, ToEnum::IAR, - ToEnum::SAR, ToEnum::IPL, ToEnum::SPL, ToEnum::IAL, ToEnum::SAL, ToEnum::PIR, ToEnum::PSR, - ToEnum::AIR, ToEnum::ASR, ToEnum::PIL, ToEnum::PSL, ToEnum::AIL, ToEnum::ASL, ToEnum::INVALID }) + auto createCodeToString = []() -> std::map { + std::map orientToString; + + for (auto code : { PositiveEnum::RIP, PositiveEnum::LIP, PositiveEnum::RSP, PositiveEnum::LSP, PositiveEnum::RIA, + PositiveEnum::LIA, PositiveEnum::RSA, PositiveEnum::LSA, PositiveEnum::IRP, PositiveEnum::ILP, + PositiveEnum::SRP, PositiveEnum::SLP, PositiveEnum::IRA, PositiveEnum::ILA, PositiveEnum::SRA, + PositiveEnum::SLA, PositiveEnum::RPI, PositiveEnum::LPI, PositiveEnum::RAI, PositiveEnum::LAI, + PositiveEnum::RPS, PositiveEnum::LPS, PositiveEnum::RAS, PositiveEnum::LAS, PositiveEnum::PRI, + PositiveEnum::PLI, PositiveEnum::ARI, PositiveEnum::ALI, PositiveEnum::PRS, PositiveEnum::PLS, + PositiveEnum::ARS, PositiveEnum::ALS, PositiveEnum::IPR, PositiveEnum::SPR, PositiveEnum::IAR, + PositiveEnum::SAR, PositiveEnum::IPL, PositiveEnum::SPL, PositiveEnum::IAL, PositiveEnum::SAL, + PositiveEnum::PIR, PositiveEnum::PSR, PositiveEnum::AIR, PositiveEnum::ASR, PositiveEnum::PIL, + PositiveEnum::PSL, PositiveEnum::AIL, PositiveEnum::ASL, PositiveEnum::INVALID }) { - orientToString[code] = AnatomicalOrientation(code).GetAsToStringEncoding(); + orientToString[code] = AnatomicalOrientation(code).GetAsPositiveStringEncoding(); } return orientToString; }; - static const std::map codeToString = createCodeToString(); + static const std::map codeToString = createCodeToString(); return codeToString; } -const std::map & +const std::map & AnatomicalOrientation::GetStringToCode() { - auto createStringToCode = []() -> std::map { - std::map stringToCode; - const std::map & codeToString = GetCodeToString(); + auto createStringToCode = []() -> std::map { + std::map stringToCode; + const std::map & codeToString = GetCodeToString(); for (const auto & kv : codeToString) { @@ -194,13 +197,13 @@ AnatomicalOrientation::GetStringToCode() return stringToCode; }; - static const std::map stringToCode = createStringToCode(); + static const std::map stringToCode = createStringToCode(); return stringToCode; } -typename AnatomicalOrientation::ToEnum -AnatomicalOrientation::DirectionCosinesToOrientation(const DirectionType & dir) +AnatomicalOrientation::PositiveEnum +AnatomicalOrientation::ConvertDirectionToPositiveEnum(const DirectionType & dir) { // NOTE: This method was based off of itk::SpatialObjectAdaptor::FromDirectionCosines // but it is DIFFERENT in the meaning of direction in terms of sign-ness. @@ -265,7 +268,7 @@ AnatomicalOrientation::DirectionCosinesToOrientation(const DirectionType & dir) typename AnatomicalOrientation::DirectionType -AnatomicalOrientation::OrientationToDirectionCosines(ToEnum orientationEnum) +AnatomicalOrientation::ConvertPositiveEnumToDirection(PositiveEnum orientationEnum) { const AnatomicalOrientation o(orientationEnum); @@ -323,15 +326,15 @@ operator<<(std::ostream & out, typename AnatomicalOrientation::CoordinateEnum va } std::ostream & -operator<<(std::ostream & out, typename AnatomicalOrientation::ToEnum value) +operator<<(std::ostream & out, typename AnatomicalOrientation::PositiveEnum value) { - return (out << AnatomicalOrientation(value).GetAsToStringEncoding()); + return (out << AnatomicalOrientation(value).GetAsPositiveStringEncoding()); } std::ostream & -operator<<(std::ostream & out, typename AnatomicalOrientation::FromEnum value) +operator<<(std::ostream & out, typename AnatomicalOrientation::NegativeEnum value) { - return (out << AnatomicalOrientation(value).GetAsFromStringEncoding()); + return (out << AnatomicalOrientation(value).GetAsNegativeStringEncoding()); } std::ostream & diff --git a/Modules/Core/Common/test/itkAnatomicalOrientationGTest.cxx b/Modules/Core/Common/test/itkAnatomicalOrientationGTest.cxx index ca271767dc0..f09b5fcf0e8 100644 --- a/Modules/Core/Common/test/itkAnatomicalOrientationGTest.cxx +++ b/Modules/Core/Common/test/itkAnatomicalOrientationGTest.cxx @@ -30,7 +30,8 @@ TEST(AnatomicalOrientation, ConstructionAndValues) { using itk::AnatomicalOrientation; - using OE = AnatomicalOrientation::ToEnum; + using OE = AnatomicalOrientation::PositiveEnum; + using NOE = AnatomicalOrientation::NegativeEnum; using CE = AnatomicalOrientation::CoordinateEnum; using ImageType = itk::Image; @@ -38,23 +39,25 @@ TEST(AnatomicalOrientation, ConstructionAndValues) AnatomicalOrientation do1(OE::LPS); - EXPECT_EQ("LPS", do1.GetAsToStringEncoding()); + EXPECT_EQ("LPS", do1.GetAsPositiveStringEncoding()); EXPECT_EQ(CE::RightToLeft, do1.GetPrimaryTerm()); EXPECT_EQ(CE::AnteriorToPosterior, do1.GetSecondaryTerm()); EXPECT_EQ(CE::InferiorToSuperior, do1.GetTertiaryTerm()); - EXPECT_EQ(OE::LPS, do1.GetAsOrientation()); + EXPECT_EQ(OE::LPS, do1.GetAsPositiveOrientation()); + EXPECT_EQ(NOE::RAI, do1.GetAsNegativeOrientation()); d.SetIdentity(); EXPECT_EQ(d, do1.GetAsDirection()); - do1 = AnatomicalOrientation::CreateFromToStringEncoding("RAS"); + do1 = AnatomicalOrientation::CreateFromPositiveStringEncoding("RAS"); - EXPECT_EQ("RAS", do1.GetAsToStringEncoding()); + EXPECT_EQ("RAS", do1.GetAsPositiveStringEncoding()); EXPECT_EQ(CE::LeftToRight, do1.GetPrimaryTerm()); EXPECT_EQ(CE::PosteriorToAnterior, do1.GetSecondaryTerm()); EXPECT_EQ(CE::InferiorToSuperior, do1.GetTertiaryTerm()); - EXPECT_EQ(OE::RAS, do1.GetAsOrientation()); + EXPECT_EQ(OE::RAS, do1.GetAsPositiveOrientation()); + EXPECT_EQ(NOE::LPI, do1.GetAsNegativeOrientation()); d.Fill(0.0); d(0, 0) = -1.0; @@ -63,22 +66,34 @@ TEST(AnatomicalOrientation, ConstructionAndValues) EXPECT_EQ(d, do1.GetAsDirection()); - do1 = AnatomicalOrientation::CreateFromToStringEncoding("rai"); + do1 = AnatomicalOrientation::CreateFromPositiveStringEncoding("rai"); - EXPECT_EQ("RAI", do1.GetAsToStringEncoding()); + EXPECT_EQ("RAI", do1.GetAsPositiveStringEncoding()); EXPECT_EQ(CE::LeftToRight, do1.GetPrimaryTerm()); EXPECT_EQ(CE::PosteriorToAnterior, do1.GetSecondaryTerm()); EXPECT_EQ(CE::SuperiorToInferior, do1.GetTertiaryTerm()); - EXPECT_EQ(OE::RAI, do1.GetAsOrientation()); + EXPECT_EQ(OE::RAI, do1.GetAsPositiveOrientation()); + EXPECT_EQ(NOE::LPS, do1.GetAsNegativeOrientation()); + do1 = AnatomicalOrientation::CreateFromNegativeStringEncoding("LPI"); + + EXPECT_EQ("RAS", do1.GetAsPositiveStringEncoding()); + EXPECT_EQ("LPI", do1.GetAsNegativeStringEncoding()); + EXPECT_EQ(CE::LeftToRight, do1.GetPrimaryTerm()); + EXPECT_EQ(CE::PosteriorToAnterior, do1.GetSecondaryTerm()); + EXPECT_EQ(CE::InferiorToSuperior, do1.GetTertiaryTerm()); + EXPECT_EQ(OE::RAS, do1.GetAsPositiveOrientation()); + EXPECT_EQ(NOE::LPI, do1.GetAsNegativeOrientation()); + do1 = AnatomicalOrientation(OE::PIR); - EXPECT_EQ("PIR", do1.GetAsToStringEncoding()); + EXPECT_EQ("PIR", do1.GetAsPositiveStringEncoding()); EXPECT_EQ(CE::AnteriorToPosterior, do1.GetPrimaryTerm()); EXPECT_EQ(CE::SuperiorToInferior, do1.GetSecondaryTerm()); EXPECT_EQ(CE::LeftToRight, do1.GetTertiaryTerm()); - EXPECT_EQ(OE::PIR, do1.GetAsOrientation()); + EXPECT_EQ(OE::PIR, do1.GetAsPositiveOrientation()); + EXPECT_EQ(NOE::ASL, do1.GetAsNegativeOrientation()); d.Fill(0.0); d(1, 0) = 1.0; @@ -88,130 +103,132 @@ TEST(AnatomicalOrientation, ConstructionAndValues) AnatomicalOrientation do2(d); - EXPECT_EQ("PIR", do2.GetAsToStringEncoding()); + EXPECT_EQ("PIR", do2.GetAsPositiveStringEncoding()); EXPECT_EQ(CE::AnteriorToPosterior, do2.GetPrimaryTerm()); EXPECT_EQ(CE::SuperiorToInferior, do2.GetSecondaryTerm()); EXPECT_EQ(CE::LeftToRight, do2.GetTertiaryTerm()); - EXPECT_EQ(OE::PIR, do2.GetAsOrientation()); + EXPECT_EQ(OE::PIR, do2.GetAsPositiveOrientation()); + EXPECT_EQ(NOE::ASL, do2.GetAsNegativeOrientation()); EXPECT_EQ(d, do2.GetAsDirection()); - AnatomicalOrientation do3 = AnatomicalOrientation::CreateFromToStringEncoding("something invalid"); - EXPECT_EQ("INVALID", do3.GetAsToStringEncoding()); + AnatomicalOrientation do3 = AnatomicalOrientation::CreateFromPositiveStringEncoding("something invalid"); + EXPECT_EQ("INVALID", do3.GetAsPositiveStringEncoding()); EXPECT_EQ(CE::UNKNOWN, do3.GetPrimaryTerm()); EXPECT_EQ(CE::UNKNOWN, do3.GetSecondaryTerm()); EXPECT_EQ(CE::UNKNOWN, do3.GetTertiaryTerm()); - EXPECT_EQ(OE::INVALID, do3.GetAsOrientation()); + EXPECT_EQ(OE::INVALID, do3.GetAsPositiveOrientation()); + EXPECT_EQ(NOE::INVALID, do3.GetAsNegativeOrientation()); } -TEST(AnatomicalOrientation, DirectionCosinesToOrientation) +TEST(AnatomicalOrientation, ConvertDirectionToPositiveEnum) { using itk::AnatomicalOrientation; - using OE = AnatomicalOrientation::ToEnum; + using OE = AnatomicalOrientation::PositiveEnum; using ImageType = itk::Image; ImageType::DirectionType d; d.SetIdentity(); - EXPECT_EQ(OE::LPS, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::LPS, AnatomicalOrientation(d)); d.Fill(0.0); d(0, 0) = -1.0; d(1, 1) = -1.0; d(2, 2) = -1.0; - EXPECT_EQ(OE::RAI, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::RAI, AnatomicalOrientation(d)); d.Fill(0.0); d(2, 0) = 1; d(0, 1) = 1; d(1, 2) = 1; - EXPECT_EQ(OE::SLP, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::SLP, AnatomicalOrientation(d)); d.Fill(0.0); d(1, 0) = 1; d(2, 1) = 1; d(0, 2) = 1; - EXPECT_EQ(OE::PSL, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::PSL, AnatomicalOrientation(d)); d.Fill(0.0); d(0, 0) = 1; d(2, 1) = 1; d(1, 2) = 1; - EXPECT_EQ(OE::LSP, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::LSP, AnatomicalOrientation(d)); d.Fill(0.0); d(1, 0) = 1; d(0, 1) = 1; d(2, 2) = 1; - EXPECT_EQ(OE::PLS, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::PLS, AnatomicalOrientation(d)); d.Fill(0.0); d(2, 0) = 1; d(1, 1) = 1; d(0, 2) = 1; - EXPECT_EQ(OE::SPL, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::SPL, AnatomicalOrientation(d)); const double data[] = { 0.5986634407395047, 0.22716302314740483, -0.768113953548866, 0.5627936241740271, 0.563067040943212, 0.6051601804419384, 0.5699696670095713, -0.794576911518317, 0.20924175102261847 }; ImageType::DirectionType::InternalMatrixType m{ data }; d.GetVnlMatrix() = m; - EXPECT_EQ(OE::PIR, AnatomicalOrientation::DirectionCosinesToOrientation(d)); + EXPECT_EQ(OE::PIR, AnatomicalOrientation(d)); } -TEST(AnatomicalOrientation, OrientationToDirectionCosines) +TEST(AnatomicalOrientation, ConvertPositiveEnumToDirection) { using itk::AnatomicalOrientation; using ImageType = itk::Image; - using OE = AnatomicalOrientation::ToEnum; + using OE = AnatomicalOrientation::PositiveEnum; ImageType::DirectionType d; d.SetIdentity(); - EXPECT_EQ(d, AnatomicalOrientation::OrientationToDirectionCosines(OE::LPS)); + EXPECT_EQ(d, AnatomicalOrientation(OE::LPS).GetAsDirection()); d.Fill(0.0); d(0, 0) = -1.0; d(1, 1) = -1.0; d(2, 2) = -1.0; - EXPECT_EQ(d, AnatomicalOrientation::OrientationToDirectionCosines(OE::RAI)); + EXPECT_EQ(d, AnatomicalOrientation(OE::RAI).GetAsDirection()); d.Fill(0.0); d(2, 0) = 1; d(0, 1) = 1; d(1, 2) = 1; - EXPECT_EQ(d, AnatomicalOrientation::OrientationToDirectionCosines(OE::SLP)); + EXPECT_EQ(d, AnatomicalOrientation(OE::SLP).GetAsDirection()); d.Fill(0.0); d(1, 0) = 1; d(2, 1) = 1; d(0, 2) = 1; - EXPECT_EQ(d, AnatomicalOrientation::OrientationToDirectionCosines(OE::PSL)); + EXPECT_EQ(d, AnatomicalOrientation(OE::PSL).GetAsDirection()); d.Fill(0.0); d(0, 0) = 1; d(2, 1) = 1; d(1, 2) = 1; - EXPECT_EQ(d, AnatomicalOrientation::OrientationToDirectionCosines(OE::LSP)); + EXPECT_EQ(d, AnatomicalOrientation(OE::LSP).GetAsDirection()); d.Fill(0.0); d(1, 0) = 1; d(0, 1) = 1; d(2, 2) = 1; - EXPECT_EQ(d, AnatomicalOrientation::OrientationToDirectionCosines(OE::PLS)); + EXPECT_EQ(d, AnatomicalOrientation(OE::PLS).GetAsDirection()); d.Fill(0.0); d(2, 0) = 1; d(1, 1) = 1; d(0, 2) = 1; - EXPECT_EQ(d, AnatomicalOrientation::OrientationToDirectionCosines(OE::SPL)); + EXPECT_EQ(d, AnatomicalOrientation(OE::SPL).GetAsDirection()); } TEST(AntomicalOrientation, ToFromEnumInteroperability) { - using OE = itk::AnatomicalOrientation::ToEnum; - using FromOE = itk::AnatomicalOrientation::FromEnum; + using OE = itk::AnatomicalOrientation::PositiveEnum; + using FromOE = itk::AnatomicalOrientation::NegativeEnum; using CE = itk::AnatomicalOrientation::CoordinateEnum; static_assert(int(OE::RAI) == int(FromOE::LPS)); @@ -224,8 +241,8 @@ TEST(AntomicalOrientation, ToFromEnumInteroperability) itk::AnatomicalOrientation itk_rai(FromOE::RAI); EXPECT_EQ(itk_rai, itk::AnatomicalOrientation(OE::LPS)); - EXPECT_EQ(itk_rai.GetAsOrientation(), OE::LPS); - EXPECT_EQ(itk_rai.GetAsToStringEncoding(), "LPS"); + EXPECT_EQ(itk_rai.GetAsPositiveOrientation(), OE::LPS); + EXPECT_EQ(itk_rai.GetAsPositiveStringEncoding(), "LPS"); const std::array expected_terms = { { CE::RightToLeft, CE::AnteriorToPosterior, CE::InferiorToSuperior } }; EXPECT_EQ(itk_rai.GetTerms(), expected_terms); } @@ -235,7 +252,7 @@ TEST(AntomicalOrientation, ToFromEnumInteroperability) TEST(AnatomicalOrientation, LegacyInteroperability) { - using OE = itk::AnatomicalOrientation::ToEnum; + using OE = itk::AnatomicalOrientation::PositiveEnum; using SOE = itk::SpatialOrientationEnums::ValidCoordinateOrientations; // byte for byte compatibility, may assist with migration of bindings when types are not strictly enforced. @@ -246,7 +263,7 @@ TEST(AnatomicalOrientation, LegacyInteroperability) itk::AnatomicalOrientation itk_rai(SOE::ITK_COORDINATE_ORIENTATION_RAI); EXPECT_EQ(itk_rai, OE::LPS); - EXPECT_EQ(itk_rai.GetAsOrientation(), OE::LPS); - EXPECT_EQ(itk_rai.GetAsToStringEncoding(), "LPS"); + EXPECT_EQ(itk_rai.GetAsPositiveOrientation(), OE::LPS); + EXPECT_EQ(itk_rai.GetAsPositiveStringEncoding(), "LPS"); } #endif diff --git a/Modules/IO/IPL/include/itkGEImageHeader.h b/Modules/IO/IPL/include/itkGEImageHeader.h index bb477d8e664..c586941c56d 100644 --- a/Modules/IO/IPL/include/itkGEImageHeader.h +++ b/Modules/IO/IPL/include/itkGEImageHeader.h @@ -87,7 +87,7 @@ struct GEImageHeader float imageXres; float imageYres; - itk::AnatomicalOrientation::ToEnum coordinateOrientation; // uint32_t + itk::AnatomicalOrientation::PositiveEnum coordinateOrientation; // uint32_t short numberOfSlices; short offset; diff --git a/Modules/IO/ImageBase/test/itkReadWriteImageWithDictionaryTest.cxx b/Modules/IO/ImageBase/test/itkReadWriteImageWithDictionaryTest.cxx index 91308882284..1b8fc5f1732 100644 --- a/Modules/IO/ImageBase/test/itkReadWriteImageWithDictionaryTest.cxx +++ b/Modules/IO/ImageBase/test/itkReadWriteImageWithDictionaryTest.cxx @@ -47,7 +47,7 @@ itkReadWriteImageWithDictionaryTest(int argc, char * argv[]) inputImage->Allocate(); inputImage->FillBuffer(0); - inputImage->SetDirection(itk::AnatomicalOrientation::CreateFromToStringEncoding("LSA").GetAsDirection()); + inputImage->SetDirection(itk::AnatomicalOrientation::CreateFromPositiveStringEncoding("LSA").GetAsDirection()); // Add some metadata in the dictionary itk::MetaDataDictionary & inputDictionary = inputImage->GetMetaDataDictionary(); diff --git a/Modules/IO/NIFTI/src/itkNiftiImageIO.cxx b/Modules/IO/NIFTI/src/itkNiftiImageIO.cxx index ed65b6767b8..c86542c7605 100644 --- a/Modules/IO/NIFTI/src/itkNiftiImageIO.cxx +++ b/Modules/IO/NIFTI/src/itkNiftiImageIO.cxx @@ -1896,7 +1896,7 @@ NiftiImageIO::SetImageIOOrientationFromNIfTI(unsigned short dims, double spacing this->GetLegacyAnalyze75Mode() != NiftiImageIOEnums::Analyze75Flavor::AnalyzeITK4 && this->GetLegacyAnalyze75Mode() != NiftiImageIOEnums::Analyze75Flavor::AnalyzeITK4Warning) { // only do this for Analyze file format - AnatomicalOrientation orient(AnatomicalOrientation::ToEnum::INVALID); + AnatomicalOrientation orient(AnatomicalOrientation::PositiveEnum::INVALID); switch (this->m_NiftiImage->analyze75_orient) { case a75_transverse_unflipped: diff --git a/Modules/IO/NIFTI/test/itkNiftiReadAnalyzeTest.cxx b/Modules/IO/NIFTI/test/itkNiftiReadAnalyzeTest.cxx index 1431e4f8903..8310b3e354e 100644 --- a/Modules/IO/NIFTI/test/itkNiftiReadAnalyzeTest.cxx +++ b/Modules/IO/NIFTI/test/itkNiftiReadAnalyzeTest.cxx @@ -184,11 +184,11 @@ itkNiftiAnalyzeContentsAndCoordinatesTest(char * { std::string hdrName(argv[1]); hdrName += "/littleEndian_"; - hdrName += expected_code.GetAsToStringEncoding(); + hdrName += expected_code.GetAsPositiveStringEncoding(); hdrName += ".hdr"; std::string imgName(argv[1]); imgName += "/littleEndian_"; - imgName += expected_code.GetAsToStringEncoding(); + imgName += expected_code.GetAsPositiveStringEncoding(); imgName += ".img"; // hack the header to have proper orientation code @@ -253,8 +253,8 @@ itkNiftiAnalyzeContentsAndCoordinatesTest(char * if (orientation_code != expected_code) { std::cerr << "Analyze orientation " << static_cast(hist_orient_code) << std::endl; - std::cerr << "expected orientation " << expected_code.GetAsToStringEncoding() << " but found " - << orientation_code.GetAsToStringEncoding() << std::endl; + std::cerr << "expected orientation " << expected_code.GetAsPositiveStringEncoding() << " but found " + << orientation_code.GetAsPositiveStringEncoding() << std::endl; return EXIT_FAILURE; } @@ -264,7 +264,7 @@ itkNiftiAnalyzeContentsAndCoordinatesTest(char * << "negative x step:" << (flip_x ? "true" : "false") << std::endl << "Origin :" << img->GetOrigin() << std::endl << "Spacing :" << img->GetSpacing() << std::endl - << "Code :" << orientation_code.GetAsToStringEncoding() << std::endl + << "Code :" << orientation_code.GetAsPositiveStringEncoding() << std::endl << "Direction:" << img->GetDirection() << std::endl; return EXIT_SUCCESS; diff --git a/Modules/IO/Siemens/src/itkSiemensVisionImageIO.cxx b/Modules/IO/Siemens/src/itkSiemensVisionImageIO.cxx index abddb7e10be..1e6b52a1290 100644 --- a/Modules/IO/Siemens/src/itkSiemensVisionImageIO.cxx +++ b/Modules/IO/Siemens/src/itkSiemensVisionImageIO.cxx @@ -223,7 +223,7 @@ SiemensVisionImageIO::ReadHeader(const char * FileNameToRead) if (text_angle_len.empty() || itk::Math::abs(std::stod(text_angle_len)) <= 45.0) { // hdr->imagePlane = itk::IOCommon::ITK_ANALYZE_ORIENTATION_IRP_CORONAL; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::RSP); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::RSP); } else { @@ -231,13 +231,13 @@ SiemensVisionImageIO::ReadHeader(const char * FileNameToRead) { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_SAGITTAL; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::AIR); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::AIR); } else { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_TRANSVERSE; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::RAI); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::RAI); } } } @@ -247,7 +247,7 @@ SiemensVisionImageIO::ReadHeader(const char * FileNameToRead) { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_SAGITTAL; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::AIR); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::AIR); } else { @@ -255,13 +255,13 @@ SiemensVisionImageIO::ReadHeader(const char * FileNameToRead) { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_CORONAL; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::RSP); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::RSP); } else { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_TRANSVERSE; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::RAI); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::RAI); } } } @@ -271,7 +271,7 @@ SiemensVisionImageIO::ReadHeader(const char * FileNameToRead) { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_TRANSVERSE; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::RAI); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::RAI); } else { @@ -279,13 +279,13 @@ SiemensVisionImageIO::ReadHeader(const char * FileNameToRead) { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_CORONAL; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::RSP); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::RSP); } else { // hdr->imagePlane = // itk::SpatialOrientationEnums::ValidCoordinateOrientations::ITK_ANALYZE_ORIENTATION_IRP_SAGITTAL; - hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::FromEnum::AIR); + hdr->coordinateOrientation = AnatomicalOrientation(itk::AnatomicalOrientation::NegativeEnum::AIR); } } }