BUG: Locale-independent DICOM DS parsing in DCMTKTransformIO

DCMTKTransformIO::Read() parsed DICOM Decimal-String matrix values with
std::stod inside a NumericLocale scope. On macOS 13 and earlier libc the
non-_l std::stod ignores the thread-local locale NumericLocale installs
via uselocale(), so transform matrices parsed wrong under a decimal-comma
locale -- the same defect as the NRRD reader.

Add NumericLocale::StringToDouble (strtod_l against a cached "C" locale,
thread-safe via a magic static) and use it at the two DS parse sites,
dropping the now-redundant RAII guard.

Replace the WorksWithDifferentInitialLocale test -- which asserted the
RAII + plain std::strtod behavior that macOS 13 libc cannot provide --
with StringToDoubleIsLocaleIndependent, exercising the robust helper.

Author: hjmjohnson

Modules/Core/Common/include/itkNumericLocale.h

@@ -64,6 +64,12 @@ class ITKCommon_EXPORT NumericLocale
   /** Destructor: Restores the original LC_NUMERIC locale */
   ~NumericLocale();
 
+  /** Parse a decimal string with an explicit "C" locale on every platform.
+   *  The RAII scope only switches the thread-local locale, which non-_l
+   *  std::strtod ignores on macOS 13 and earlier libc; this uses strtod_l. */
+  static double
+  StringToDouble(const char * str);
+
   // Delete copy and move operations
   NumericLocale(const NumericLocale &) = delete;
   NumericLocale &

Modules/Core/Common/src/itkNumericLocale.cxx

@@ -34,6 +34,23 @@
 namespace itk
 {
 
+// Parse with an explicit "C" locale so the result is locale-independent even
+// where non-_l std::strtod ignores the thread-local locale (macOS 13 libc).
+// The function-local static is thread-safe by C++11 magic-static semantics.
+double
+NumericLocale::StringToDouble(const char * str)
+{
+#if defined(ITK_HAS_NEWLOCALE)
+  static const locale_t cLocale = newlocale(LC_NUMERIC_MASK, "C", static_cast<locale_t>(nullptr));
+  return cLocale ? strtod_l(str, nullptr, cLocale) : std::strtod(str, nullptr);
+#elif defined(ITK_HAS_CONFIGTHREADLOCALE)
+  static const _locale_t cLocale = _create_locale(LC_NUMERIC, "C");
+  return cLocale ? _strtod_l(str, nullptr, cLocale) : std::strtod(str, nullptr);
+#else
+  return std::strtod(str, nullptr);
+#endif
+}
+
 // Implementation structure definition
 struct NumericLocale::Impl
 {

Modules/Core/Common/test/itkNumericLocaleGTest.cxx

@@ -87,60 +87,6 @@ TEST(NumericLocale, SupportsNesting)
   EXPECT_STREQ(setlocale(LC_NUMERIC, nullptr), savedInitialLocale.c_str());
 }
 
-// Test with a different locale if available (optional test)
-TEST(NumericLocale, WorksWithDifferentInitialLocale)
-{
-  // Try to set a locale with comma as decimal separator
-  const char * decimalCommaLocales[] = { "de_DE.UTF-8", "bs_BA.UTF-8", "bs-Latn-BA.UTF-8", "fr_FR.UTF-8" };
-
-  unsigned countAvailableLocales = 0;
-  for (const char * locale : decimalCommaLocales)
-  {
-    const char * decimalCommaLocale = setlocale(LC_NUMERIC, locale);
-    if (decimalCommaLocale != nullptr)
-    {
-      // Verify we're in German locale (comma separator)
-      const char * currentLocale = setlocale(LC_NUMERIC, nullptr);
-      ASSERT_NE(currentLocale, nullptr);
-      std::string savedLocale(currentLocale);
-
-      // Without NumericLocale, parsing with dot would fail in German locale
-      // (This test verifies the problem we're fixing)
-      double valueWithoutFix = std::strtod("0.878906", nullptr);
-      // In de_DE locale, this would parse as 0.0 (stops at dot)
-      EXPECT_EQ(valueWithoutFix, 0.0);
-
-      {
-        // With NumericLocale, parsing should work correctly
-        itk::NumericLocale numericLocale;
-
-        double valueWithFix = std::strtod("0.878906", nullptr);
-        EXPECT_DOUBLE_EQ(valueWithFix, 0.878906);
-
-        double value2 = std::strtod("3.5", nullptr);
-        EXPECT_DOUBLE_EQ(value2, 3.5);
-      }
-
-      // After NumericLocale destroyed, we should be back in German locale
-      EXPECT_STREQ(setlocale(LC_NUMERIC, nullptr), savedLocale.c_str());
-
-      // Restore to C locale for other tests
-      setlocale(LC_NUMERIC, "C");
-      ++countAvailableLocales;
-    }
-  }
-  if (countAvailableLocales == 0)
-  {
-    GTEST_SKIP() << "Decimal-comma locales not available on this system. Locales tried: "
-                 << sizeof(decimalCommaLocales) / sizeof(char *)
-                 << ". Consider installing locales by\nsudo locale-gen de_DE.UTF-8";
-  }
-  else
-  {
-    std::cout << "Passed. Tested with " << countAvailableLocales << " decimal-comma locales." << std::endl;
-  }
-}
-
 // Test that multiple sequential uses work correctly
 TEST(NumericLocale, SupportsSequentialUses)
 {
@@ -167,3 +113,27 @@ TEST(NumericLocale, BasicRAII)
   // Locale should be restored
   EXPECT_STREQ(setlocale(LC_NUMERIC, nullptr), savedInitialLocale.c_str());
 }
+
+// StringToDouble must parse '.' decimals regardless of the ambient locale,
+// even where non-_l std::strtod ignores uselocale() (macOS 13 libc).
+TEST(NumericLocale, StringToDoubleIsLocaleIndependent)
+{
+  const char * commaLocales[] = { "de_DE.UTF-8", "fr_FR.UTF-8", "nl_NL.UTF-8", "it_IT.UTF-8" };
+  unsigned int tested = 0;
+  for (const char * locale : commaLocales)
+  {
+    if (setlocale(LC_NUMERIC, locale) == nullptr)
+    {
+      continue;
+    }
+    ++tested;
+    EXPECT_NEAR(itk::NumericLocale::StringToDouble("0.878906"), 0.878906, 1e-9);
+    EXPECT_NEAR(itk::NumericLocale::StringToDouble("3.5"), 3.5, 1e-9);
+  }
+  setlocale(LC_NUMERIC, "C");
+  EXPECT_DOUBLE_EQ(itk::NumericLocale::StringToDouble("2.25"), 2.25);
+  if (tested == 0)
+  {
+    GTEST_SKIP() << "No decimal-comma locale installed to exercise the ambient-locale case.";
+  }
+}

Modules/IO/IOTransformDCMTK/src/itkDCMTKTransformIO.hxx

@@ -90,10 +90,6 @@ template <typename TInternalComputationValueType>
 void
 DCMTKTransformIO<TInternalComputationValueType>::Read()
 {
-  // DICOM Decimal-String values use '.' as decimal separator regardless
-  // of system locale; force LC_NUMERIC=C for std::stod parsing below.
-  const NumericLocale cLocale;
-
   TransformListType & transformList = this->GetReadTransformList();
   transformList.clear();
 
@@ -215,7 +211,7 @@ DCMTKTransformIO<TInternalComputationValueType>::Read()
                     itkExceptionMacro("Could not get expected matrix entry.");
                   }
                   ++matrixEntryIndex;
-                  transformParameters[row * Dimension + col] = std::stod(matrixString.c_str());
+                  transformParameters[row * Dimension + col] = NumericLocale::StringToDouble(matrixString.c_str());
                 }
                 result = currentMatrixSequenceItem->findAndGetOFString(
                   DCM_FrameOfReferenceTransformationMatrix, matrixString, matrixEntryIndex);
@@ -224,7 +220,7 @@ DCMTKTransformIO<TInternalComputationValueType>::Read()
                   itkExceptionMacro("Could not get expected matrix entry.");
                 }
                 ++matrixEntryIndex;
-                transformParameters[Dimension * Dimension + row] = std::stod(matrixString.c_str());
+                transformParameters[Dimension * Dimension + row] = NumericLocale::StringToDouble(matrixString.c_str());
               }
               affineTransform->SetParameters(transformParameters);