BUG: NrrdIO parse floats locale-independently via strtod_l

All NRRD floating-point parsing funnels through airSingleSscanf(), which
handed decimal strings to sscanf() -- honoring the process/thread
LC_NUMERIC locale. In a decimal-comma locale (e.g. de_DE.UTF-8),
"0.878906" parsed as 0, corrupting NRRD spacings, space directions,
origins, and ASCII-encoded pixel values.

Parse the single floating-point value at that choke point with strtod_l()
against a cached "C" locale (POSIX newlocale + pthread_once; Windows
_create_locale + atomic-CAS publish; sscanf() fallback where the *_l API
is unavailable). Behavior is unchanged where the feature is absent.

This is the ITK-vendored counterpart of the upstream teem branch
locale-independent-numeric-parse.

Author: hjmjohnson

Modules/ThirdParty/NrrdIO/src/NrrdIO/parseAir.c

@@ -23,8 +23,60 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 
+/* Enable the POSIX-2008 thread-safe locale API (newlocale/strtod_l) where
+   available; must precede the first system-header include (NrrdIO.h pulls in
+   <stdlib.h>).  NRRDIO_HAS_STRTOD_L selects a locale-independent numeric parse
+   in airSingleSscanf(); platforms lacking it keep the historical sscanf(). */
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)                    \
+  || defined(__OpenBSD__) || defined(__DragonFly__)
+#  include <xlocale.h>
+#  include <pthread.h>
+#  define NRRDIO_HAS_STRTOD_L 1
+#elif defined(__GLIBC__)
+#  ifndef _GNU_SOURCE
+#    define _GNU_SOURCE 1
+#  endif
+#  include <locale.h>
+#  include <pthread.h>
+#  define NRRDIO_HAS_STRTOD_L 1
+#elif defined(_MSC_VER)
+#  include <locale.h>
+#  include <intrin.h>
+#  define NRRDIO_HAS_STRTOD_L_WIN 1
+#endif
+
 #include "NrrdIO.h"
 
+#if defined(NRRDIO_HAS_STRTOD_L)
+/* Cached "C" locale for locale-independent strtod_l; created once. */
+static locale_t _nrrdCLocale = (locale_t)0;
+static pthread_once_t _nrrdCLocaleOnce = PTHREAD_ONCE_INIT;
+static void
+_nrrdCLocaleInit(void) {
+  _nrrdCLocale = newlocale(LC_NUMERIC_MASK, "C", (locale_t)0);
+}
+static locale_t
+_nrrdGetCLocale(void) {
+  pthread_once(&_nrrdCLocaleOnce, _nrrdCLocaleInit);
+  return _nrrdCLocale;
+}
+#elif defined(NRRDIO_HAS_STRTOD_L_WIN)
+/* Cached "C" locale published exactly once via an atomic pointer CAS, so
+   concurrent first use is race-free: the losing thread frees its duplicate. */
+static void *volatile _nrrdCLocale = NULL;
+static _locale_t
+_nrrdGetCLocale(void) {
+  _locale_t loc = (_locale_t)_nrrdCLocale;
+  if (!loc) {
+    _locale_t created = _create_locale(LC_NUMERIC, "C");
+    void *prev = _InterlockedCompareExchangePointer(&_nrrdCLocale, created, NULL);
+    if (prev) { _free_locale(created); loc = (_locale_t)prev; }
+    else      { loc = created; }
+  }
+  return loc;
+}
+#endif
+
 /* clang-format off */
 static const char *
 boolStr[] = {
@@ -105,12 +157,32 @@ airSingleSscanf(const char *str, const char *fmt, void *ptr) {
     } else if (strstr(tmp, "inf")) {
       val = (double)AIR_POS_INF;
     } else {
-      /* nothing special matched; pass it off to sscanf() */
-      /* (save setlocale here) */
+      /* nothing special matched; parse one floating-point value with a
+         locale-independent "C" parse so NRRD's '.' decimal separator is
+         honored regardless of the process/thread LC_NUMERIC setting. */
+#if defined(NRRDIO_HAS_STRTOD_L) || defined(NRRDIO_HAS_STRTOD_L_WIN)
+      char *endptr = NULL;
+      double dval;
+#  if defined(NRRDIO_HAS_STRTOD_L)
+      locale_t cloc = _nrrdGetCLocale();
+      dval = cloc ? strtod_l(str, &endptr, cloc) : strtod(str, &endptr);
+#  else
+      _locale_t cloc = _nrrdGetCLocale();
+      dval = cloc ? _strtod_l(str, &endptr, cloc) : strtod(str, &endptr);
+#  endif
+      ret = (endptr != str) ? 1 : 0;
+      if (ret) {
+        if (fmt[1] == 'l') { *((double *)(ptr)) = dval; }
+        else               { *((float *)(ptr)) = AIR_FLOAT(dval); }
+      }
+      free(tmp);
+      return ret;
+#else
+      /* fallback: historical locale-dependent behavior, unchanged */
       ret = sscanf(str, fmt, ptr);
-      /* (return setlocale here) */
       free(tmp);
       return ret;
+#endif
     }
     /* else we matched "nan", "-inf", or "inf"; now set val accordingly */
     if (fmt[1] == 'l') {