ENH: Add precision round-trip tests for float metadata serialization

Adds test coverage to four IO modules verifying that float/double values
survive disk round-trips without the 6-digit truncation that default
stream precision introduces (ITK issue #3249):

* itkNiftiImageIOTest3.cxx: TestNiftiFloatMetadataPrecision() writes an
  image with 0.12345679-mm spacing, reads back, and verifies the
  MetaDataDictionary["pixdim[1]"] string parses to the exact float32.

* itkMetaImageIOMetaDataTest.cxx: encapsulates hpDouble=1.2345678901234568
  and hpFloat=1.2345679f, writes/reads MetaImage, checks exact equality
  via stod/stof (bypassing the loose 1e-6 tolerance in Equal<double>).

* itkNrrdMetaDataTest.cxx: same pattern for native double and float
  NRRD metadata keys.

* itkVoxBoCUBImageIOTest.cxx: creates an image with 0.12345678901234
  spacing, writes/reads CUB, asserts GetSpacing()[0] == original double.

These tests FAIL without the ConvertNumberToString fixes in PR #6003
and PASS after them (Closes #3249).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hjmjohnson

Modules/IO/Meta/test/itkMetaImageIOMetaDataTest.cxx

@@ -21,6 +21,7 @@
 #include "itkRandomImageSource.h"
 #include "itkMetaDataObject.h"
 #include "itkMetaImageIO.h"
+#include "itkNumberToString.h"
 #include "itkTestingMacros.h"
 
 
@@ -341,5 +342,60 @@ itkMetaImageIOMetaDataTest(int argc, char * argv[])
     return 1; // error
   }
 
+  // Precision test: verify that double and float metadata round-trips without
+  // the 6-digit truncation introduced by default stream precision.
+  //
+  // With default stream precision the MetaImageIO write path serialised a
+  // double like 1.2345678901234568 as "1.23457", which on read-back parses
+  // to a different double bit-pattern.  itk::ConvertNumberToString() produces
+  // the shortest decimal string that round-trips exactly.
+  //
+  // These checks FAIL against the unfixed MetaImageIO and PASS with the fix.
+  {
+    // Values chosen to require more than 6 significant decimal digits.
+    constexpr double hpDouble = 1.2345678901234568;
+    constexpr float  hpFloat = 1.2345679f;
+
+    ImageType::Pointer        precImage(source->GetOutput());
+    itk::MetaDataDictionary & precDict = precImage->GetMetaDataDictionary();
+    itk::EncapsulateMetaData<double>(precDict, std::string("high_precision_double"), hpDouble);
+    itk::EncapsulateMetaData<float>(precDict, std::string("high_precision_float"), hpFloat);
+
+    WriteImage<ImageType>(precImage, argv[1]);
+
+    const ImageType::Pointer  precImage2 = ReadImage<ImageType>(argv[1]);
+    itk::MetaDataDictionary & precDict2 = precImage2->GetMetaDataDictionary();
+
+    // Extract raw string and parse back with exact equality to detect
+    // any bit-level precision loss from the string serialization.
+    std::string doubleStr;
+    if (!itk::ExposeMetaData<std::string>(precDict2, std::string("high_precision_double"), doubleStr))
+    {
+      std::cerr << "Key high_precision_double not found after round-trip\n";
+      return 1;
+    }
+    const double parsedDouble = std::stod(doubleStr);
+    if (parsedDouble != hpDouble)
+    {
+      std::cerr << "Double precision loss: stored " << itk::ConvertNumberToString(hpDouble) << " but string '"
+                << doubleStr << "' parses to " << itk::ConvertNumberToString(parsedDouble) << '\n';
+      return 1;
+    }
+
+    std::string floatStr;
+    if (!itk::ExposeMetaData<std::string>(precDict2, std::string("high_precision_float"), floatStr))
+    {
+      std::cerr << "Key high_precision_float not found after round-trip\n";
+      return 1;
+    }
+    const float parsedFloat = std::stof(floatStr);
+    if (parsedFloat != hpFloat)
+    {
+      std::cerr << "Float precision loss: stored " << itk::ConvertNumberToString(hpFloat) << " but string '" << floatStr
+                << "' parses to " << itk::ConvertNumberToString(parsedFloat) << '\n';
+      return 1;
+    }
+  }
+
   return 0;
 }

Modules/IO/NIFTI/test/itkNiftiImageIOTest3.cxx

@@ -17,6 +17,7 @@
  *=========================================================================*/
 
 #include "itkNiftiImageIOTest.h"
+#include "itkNumberToString.h"
 #include <type_traits> // for enable_if
 #include <limits>
 
@@ -284,6 +285,94 @@ TestImageOfVectors(const std::string & fname, const std::string & intentCode = "
   return same ? 0 : EXIT_FAILURE;
 }
 
+/** Verify that NIfTI pixdim[] float header fields round-trip without
+ *  precision loss through the string metadata dictionary.
+ *
+ *  NIfTI stores spatial information (pixdim[]) as binary float32.  When ITK
+ *  reads a NIfTI file it converts these values to strings in the
+ *  MetaDataDictionary.  With default stream precision (6 sig-digits) a value
+ *  like 0.12345679f would be serialised as "0.123457", which parses back to a
+ *  different float.  With itk::ConvertNumberToString() the round-trip is exact.
+ *
+ *  This test FAILS without the ConvertNumberToString fix in itkNiftiImageIO.cxx.
+ */
+int
+TestNiftiFloatMetadataPrecision(const std::string & fname)
+{
+  using ImageType = itk::Image<float, 3>;
+  auto                image = ImageType::New();
+  ImageType::SizeType size;
+  size.Fill(2);
+  image->SetRegions(size);
+  image->Allocate(true);
+
+  // Choose a spacing value that needs more than 6 significant decimal digits.
+  // NIfTI stores spacing as float32 in pixdim[].
+  // The write path casts GetSpacing(0) to float; the read path converts that
+  // float32 back to a string stored in MetaDataDictionary["pixdim[1]"].
+  // stof("0.123457") != 0.12345679f, so the default-precision string loses
+  // information.  ConvertNumberToString produces the shortest exact string.
+  constexpr double spacingValue = 0.123456789;
+  // The float32 that will actually be stored in the NIfTI binary header:
+  const float spacingAsFloat = static_cast<float>(spacingValue);
+
+  ImageType::SpacingType spacing;
+  spacing[0] = spacingValue;
+  spacing[1] = 1.0;
+  spacing[2] = 1.0;
+  image->SetSpacing(spacing);
+
+  try
+  {
+    itk::IOTestHelper::WriteImage<ImageType, itk::NiftiImageIO>(image, fname);
+  }
+  catch (const itk::ExceptionObject & ex)
+  {
+    std::cerr << "TestNiftiFloatMetadataPrecision: write failed: " << ex << '\n';
+    return EXIT_FAILURE;
+  }
+
+  ImageType::Pointer readback;
+  try
+  {
+    readback = itk::IOTestHelper::ReadImage<ImageType>(fname);
+  }
+  catch (const itk::ExceptionObject & ex)
+  {
+    std::cerr << "TestNiftiFloatMetadataPrecision: read failed: " << ex << '\n';
+    itk::IOTestHelper::Remove(fname.c_str());
+    return EXIT_FAILURE;
+  }
+
+  // The MetaDataDictionary key for pixdim[1] (spacing along dimension 0).
+  const itk::MetaDataDictionary & rdict = readback->GetMetaDataDictionary();
+  bool                            pass = true;
+
+  std::string pixdim1Str;
+  if (itk::ExposeMetaData<std::string>(rdict, "pixdim[1]", pixdim1Str))
+  {
+    const float parsedSpacing = std::stof(pixdim1Str);
+    if (parsedSpacing != spacingAsFloat)
+    {
+      std::cerr << "pixdim[1] precision loss: stored float32 " << itk::ConvertNumberToString(spacingAsFloat)
+                << " but MetaData string '" << pixdim1Str << "' parses to " << itk::ConvertNumberToString(parsedSpacing)
+                << '\n';
+      pass = false;
+    }
+  }
+  else
+  {
+    std::cerr << "pixdim[1] key not found after round-trip\n";
+    pass = false;
+  }
+
+  if (pass)
+  {
+    itk::IOTestHelper::Remove(fname.c_str());
+  }
+  return pass ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
 /** Test writing and reading a Vector Image
  */
 int
@@ -323,5 +412,7 @@ itkNiftiImageIOTest3(int argc, char * argv[])
   success |= TestImageOfVectors<double, 3, 1>(std::string("testDispacementImage_double.nii.gz"), std::string("1006"));
   success |= TestImageOfVectors<float, 3, 1>(std::string("testDisplacementImage_float.nii.gz"), std::string("1006"));
 
+  success |= TestNiftiFloatMetadataPrecision(std::string("testFloatMetadataPrecision.nii.gz"));
+
   return success;
 }

Modules/IO/NRRD/test/itkNrrdMetaDataTest.cxx

@@ -18,6 +18,7 @@
 #include "itkImageFileReader.h"
 #include "itkImageFileWriter.h"
 #include "itkMetaDataObject.h"
+#include "itkNumberToString.h"
 #include "itksys/SystemTools.hxx"
 #include "itkNrrdImageIO.h"
 
@@ -90,10 +91,86 @@ itkNrrdMetaDataTest(int argc, char * argv[])
   std::string NrrdTest;
   // if it exists and the string matches what we put in on the image
   // to write, AOK.
-  if (itk::ExposeMetaData<std::string>(dict, metaDataObjectName, NrrdTest) != false && NrrdTest == metaDataObjectValue)
+  if (itk::ExposeMetaData<std::string>(dict, metaDataObjectName, NrrdTest) == false || NrrdTest != metaDataObjectValue)
   {
-    return EXIT_SUCCESS;
+    return EXIT_FAILURE; // oops!
   }
-  // oops!
-  return EXIT_FAILURE;
+
+  // Precision test: verify that native double and float metadata round-trips
+  // without the 6-digit truncation from default stream precision.
+  //
+  // The NrrdImageIO write path serialises native double/float metadata via
+  // _dump_metadata_to_stream<T>.  Without the ConvertNumberToString fix the
+  // output is truncated to 6 significant digits.  The read-back string then
+  // parses to a different bit-pattern.
+  //
+  // These checks FAIL against the unfixed NrrdImageIO and PASS with the fix.
+  {
+    constexpr double   hpDouble = 1.2345678901234568;
+    constexpr float    hpFloat = 1.2345679f;
+    const char * const hpDoubleKey = "high_precision_double";
+    const char * const hpFloatKey = "high_precision_float";
+
+    // Write a fresh image with high-precision double and float metadata.
+    itk::MetaDataDictionary & dict2 = image1->GetMetaDataDictionary();
+    itk::EncapsulateMetaData<double>(dict2, hpDoubleKey, hpDouble);
+    itk::EncapsulateMetaData<float>(dict2, hpFloatKey, hpFloat);
+
+    std::string precFname = argv[1];
+    precFname += "/metadatatest_precision.nrrd";
+
+    auto precWriter = ImageWriterType::New();
+    precWriter->SetImageIO(itk::NrrdImageIO::New());
+    precWriter->SetFileName(precFname.c_str());
+    precWriter->SetInput(image1);
+
+    auto precReader = ImageReaderType::New();
+    precReader->SetFileName(precFname.c_str());
+    precReader->SetImageIO(itk::NrrdImageIO::New());
+
+    try
+    {
+      precWriter->Update();
+      precReader->Update();
+    }
+    catch (const itk::ExceptionObject & ex)
+    {
+      std::cerr << "Precision test write/read failed: " << ex << '\n';
+      return EXIT_FAILURE;
+    }
+
+    const itk::MetaDataDictionary & rdict = precReader->GetOutput()->GetMetaDataDictionary();
+
+    std::string doubleStr;
+    if (!itk::ExposeMetaData<std::string>(rdict, hpDoubleKey, doubleStr))
+    {
+      std::cerr << "Key " << hpDoubleKey << " not found after round-trip\n";
+      return EXIT_FAILURE;
+    }
+    const double parsedDouble = std::stod(doubleStr);
+    if (parsedDouble != hpDouble)
+    {
+      std::cerr << "Double precision loss: stored " << itk::ConvertNumberToString(hpDouble) << " but NRRD string '"
+                << doubleStr << "' parses to " << itk::ConvertNumberToString(parsedDouble) << '\n';
+      return EXIT_FAILURE;
+    }
+
+    std::string floatStr;
+    if (!itk::ExposeMetaData<std::string>(rdict, hpFloatKey, floatStr))
+    {
+      std::cerr << "Key " << hpFloatKey << " not found after round-trip\n";
+      return EXIT_FAILURE;
+    }
+    const float parsedFloat = std::stof(floatStr);
+    if (parsedFloat != hpFloat)
+    {
+      std::cerr << "Float precision loss: stored " << itk::ConvertNumberToString(hpFloat) << " but NRRD string '"
+                << floatStr << "' parses to " << itk::ConvertNumberToString(parsedFloat) << '\n';
+      return EXIT_FAILURE;
+    }
+
+    itksys::SystemTools::RemoveFile(precFname);
+  }
+
+  return EXIT_SUCCESS;
 }

Modules/Nonunit/Review/test/itkVoxBoCUBImageIOTest.cxx

@@ -20,7 +20,10 @@
 #include "itkImageFileWriter.h"
 
 #include "itkVoxBoCUBImageIOFactory.h"
+#include "itkVoxBoCUBImageIO.h"
+#include "itkNumberToString.h"
 #include "itkTestingMacros.h"
+#include "itksys/SystemTools.hxx"
 
 int
 itkVoxBoCUBImageIOTest(int argc, char * argv[])
@@ -51,6 +54,53 @@ itkVoxBoCUBImageIOTest(int argc, char * argv[])
 
   ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update());
 
+  // Precision test: verify that voxel spacing round-trips without the
+  // 6-digit truncation introduced by default stream precision.
+  //
+  // The VoxBoCUBImageIO write path serialises m_Spacing[] as text in the CUB
+  // header.  Without the ConvertNumberToString fix the string has only 6
+  // significant digits, so reading back produces a different double value.
+  //
+  // This sub-test FAILS against the unfixed VoxBoCUBImageIO.
+  {
+    // Choose a spacing value that needs more than 6 significant decimal digits.
+    constexpr double hpSpacing = 0.123456789012345;
+
+    auto                precImage = ImageType::New();
+    ImageType::SizeType precSize;
+    precSize.Fill(2);
+    precImage->SetRegions(precSize);
+    precImage->Allocate(true);
+
+    ImageType::SpacingType spacing;
+    spacing[0] = hpSpacing;
+    spacing[1] = hpSpacing;
+    spacing[2] = hpSpacing;
+    precImage->SetSpacing(spacing);
+
+    const std::string precFname = std::string(argv[2]) + "_precision.cub";
+
+    auto precWriter = WriterType::New();
+    precWriter->SetFileName(precFname.c_str());
+    precWriter->SetImageIO(itk::VoxBoCUBImageIO::New());
+    precWriter->SetInput(precImage);
+
+    auto precReader = ReaderType::New();
+    precReader->SetFileName(precFname.c_str());
+    precReader->SetImageIO(itk::VoxBoCUBImageIO::New());
+
+    ITK_TRY_EXPECT_NO_EXCEPTION(precWriter->Update());
+    ITK_TRY_EXPECT_NO_EXCEPTION(precReader->Update());
+
+    const double readSpacing = precReader->GetOutput()->GetSpacing()[0];
+    itksys::SystemTools::RemoveFile(precFname);
+    if (readSpacing != hpSpacing)
+    {
+      std::cerr << "VoxBoCUB spacing precision loss: wrote " << itk::ConvertNumberToString(hpSpacing)
+                << " but read back " << itk::ConvertNumberToString(readSpacing) << '\n';
+      return EXIT_FAILURE;
+    }
+  }
 
   std::cout << "Test finished." << std::endl;
   return EXIT_SUCCESS;