BUG: Avizo uniform export changes sample placement and spacing

I limiti errati derivano dal calcolo origin + spacing * dimension in generateHeader in src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/WriteAvizoUniformCoordinate.cpp (intorno alla riga 69). Confrontalo con la formula del centro campione in ImageGeom.cpp. Aggiungi il TEST_CASE fornito a src/Plugins/SimplnxCore/test/WriteAvizoUniformCoordinateTest.cpp ed esegui il selettore [AvizoUniformCenters]. È completato quando la BoundingBox è 11 15 -3.5 -0.5 4 4 sia per ASCII sia per binario, gli assi singleton mantengono limiti uguali e le aspettative dell'exemplar legacy sono aggiornate.

Problem

WriteAvizoUniformCoordinateFilter exports ImageGeom outer boundaries as an AmiraMesh sample-center BoundingBox. An AmiraMesh reader therefore changes both sample placement and spacing. A singleton axis also gets unequal bounds.

Reproduced at fe6c4a15e5a5bffef2523f52cec01be33b1e62a9 using Windows x64, MSVC 19.44, Release, in-memory stores.

Expected BoundingBox: 11 15 -3.5 -0.5 4 4. Actual in both encodings: 10 16 -5 1 2 6. X spacing becomes 3 instead of 2, and Y spacing becomes 6 instead of 3.

Steps to Reproduce

1. Create an ImageGeom with dimensions [3,2,1], origin [10,-5,2], and spacing [2,3,4].
2. Attach scalar Int32 cell labels [101,102,103,104,105,106] in X-fastest order, with tuple shape [1,2,3].
3. Preflight and execute the writer with units microns. The test below selects the required encoding(s).
4. Inspect the coordinate metadata/payload against the expectations above. Preflight and execution both succeed.

Cause

src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/WriteAvizoUniformCoordinate.cpp, line 69 writes origin through origin + spacing * dimension. The AmiraMesh format manual, printed page 198 / PDF page 200 defines BoundingBox using first and last sample centers and equal bounds for a singleton axis. The ImageGeom center calculation uses origin + (index + 0.5) * spacing.

Verification Unit Test

Add this case and its local helpers to src/Plugins/SimplnxCore/test/WriteAvizoUniformCoordinateTest.cpp. It creates its own input and requires no dataset download. The following complete source was compiled and run in an isolated Catch2 harness linked to the matching Release simplnx and SimplnxCore libraries. No production source was changed.

#include "SimplnxCore/Filters/WriteAvizoRectilinearCoordinateFilter.hpp"
#include "SimplnxCore/Filters/WriteAvizoUniformCoordinateFilter.hpp"
#include "simplnx/Common/Bit.hpp"
#include "simplnx/DataStructure/AttributeMatrix.hpp"
#include "simplnx/DataStructure/DataArray.hpp"
#include "simplnx/DataStructure/Geometry/ImageGeom.hpp"
#include "simplnx/Parameters/FileSystemPathParameter.hpp"
#include "simplnx/UnitTest/UnitTestCommon.hpp"

#include <catch2/catch.hpp>

#include <array>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <sstream>

using namespace nx::core;

namespace
{
template <class FilterT>
std::string writeFixture(bool binary, const std::string& name)
{
  UnitTest::LoadPlugins();
  DataStructure dataStructure;
  auto* image = ImageGeom::Create(dataStructure, "Image");
  REQUIRE(image != nullptr);
  image->setDimensions({3, 2, 1});
  image->setOrigin({10.0f, -5.0f, 2.0f});
  image->setSpacing({2.0f, 3.0f, 4.0f});
  auto* cells = AttributeMatrix::Create(dataStructure, "Cells", {1, 2, 3}, image->getId());
  REQUIRE(cells != nullptr);
  image->setCellData(*cells);
  auto* labels = Int32Array::CreateWithStore<Int32DataStore>(dataStructure, "FeatureIds", {1, 2, 3}, {1}, cells->getId());
  REQUIRE(labels != nullptr);
  for(usize index = 0; index < 6; ++index)
  {
    (*labels)[index] = static_cast<int32>(101 + index);
  }
  UnitTest::CheckArraysInheritTupleDims(dataStructure);
  const auto path = std::filesystem::current_path() / name;
  FilterT filter;
  auto args = filter.getDefaultArguments();
  args.insertOrAssign(FilterT::k_OutputFile_Key, std::make_any<FileSystemPathParameter::ValueType>(path));
  args.insertOrAssign(FilterT::k_WriteBinaryFile_Key, std::make_any<bool>(binary));
  args.insertOrAssign(FilterT::k_GeometryPath_Key, std::make_any<DataPath>(DataPath({"Image"})));
  args.insertOrAssign(FilterT::k_FeatureIdsArrayPath_Key, std::make_any<DataPath>(DataPath({"Image", "Cells", "FeatureIds"})));
  args.insertOrAssign(FilterT::k_Units_Key, std::make_any<std::string>("microns"));
  const auto preflight = filter.preflight(dataStructure, args);
  SIMPLNX_RESULT_REQUIRE_VALID(preflight.outputActions);
  const auto execution = filter.execute(dataStructure, args);
  SIMPLNX_RESULT_REQUIRE_VALID(execution.result);
  std::ifstream stream(path, std::ios::binary);
  REQUIRE(stream.is_open());
  return {std::istreambuf_iterator<char>(stream), std::istreambuf_iterator<char>()};
}

usize payloadOffset(const std::string& contents, const std::string& marker)
{
  const auto position = contents.find("\n" + marker);
  REQUIRE(position != std::string::npos);
  const auto newline = contents.find('\n', position + 1);
  REQUIRE(newline != std::string::npos);
  return newline + 1;
}

} // namespace

TEST_CASE("Avizo uniform bounding box preserves sample centers", "[AvizoUniformCenters]")
{
  for(bool binary : {false, true})
  {
    CAPTURE(binary);
    const auto contents = writeFixture<WriteAvizoUniformCoordinateFilter>(binary, binary ? "uniform_binary.am" : "uniform_ascii.am");
    const auto position = contents.find("     BoundingBox ");
    REQUIRE(position != std::string::npos);
    std::istringstream values(contents.substr(position));
    std::string keyword;
    values >> keyword;
    REQUIRE(keyword == "BoundingBox");
    // AmiraMesh bounds are the first and last sample centers, including singleton axes.
    const std::array<double, 6> expected = {11.0, 15.0, -3.5, -0.5, 4.0, 4.0};
    for(usize component = 0; component < expected.size(); ++component)
    {
      double actual = 0.0;
      REQUIRE(static_cast<bool>(values >> actual));
      CAPTURE(component);
      CHECK(actual == Approx(expected[component]).margin(1.0e-6));
    }
  }
}

The executed harness registered AvizoUniformCenters with the Catch2 selector [AvizoUniformCenters] and ran:

ctest --test-dir <AvizoContractRepro-build> -C Release -j 1 -R "^AvizoUniformCenters$" --output-on-failure

For a standard plugin test build, register the same selector if it is not discovered automatically:

add_test(NAME AvizoUniformCenters COMMAND SimplnxCoreUnitTest "[AvizoUniformCenters]" --reporter compact)

Observed failure excerpt:

actual == Approx(expected[component]): 10.0 == Approx(11.0)
actual == Approx(expected[component]): 16.0 == Approx(15.0)
Failed 1 test case, failed 12 assertions.

An independent native control passed for all four writer/encoding combinations: every label, dimension and units string was preserved. Output-overwrite warnings occurred because cases shared their generated filenames; the failures above are numeric assertions, not preflight or file-open failures.

Proposed Fix

In WriteAvizoUniformCoordinate::generateHeader, use origin + 0.5 * spacing for the minimum and origin + (dimension - 0.5) * spacing for the maximum. Cover every axis and preserve equal endpoints when the dimension is one. Update legacy exemplar expectations only after independent coordinate checks pass.

Notes

Fixes belong on a separate source branch. No fix was applied or tested. Actual Avizo application behavior, other platforms and OOC storage were not tested. This defect blocks a proposed faithful-coordinate export comparison using the existing measured Gille LabDCT ROI.