BUG: Harden CopyIterationBenchmark to not crash on ITK 1d87efa52+ regression

The previous CreateAndInitializeImage used
  it.Set(static_cast<PixelType>(count));
to seed pixel values. For scalar and FixedArray pixels this
performs a value cast, but for VectorImage (where PixelType is
itk::VariableLengthVector<T>) it invokes the LENGTH constructor —
producing a vector of size 'count', not a N-component pixel with
value 'count'. In particular the first iteration produces a
length-0 VLV, which ITK commit 1d87efa52 changed to store a null
data pointer.

Under ITK >= 1d87efa52, the iterator's implicit copy of
NumberOfComponentsPerPixel elements from that null source causes
a SIGSEGV. Under earlier ITK, the out-of-spec read 'happens to
work' by reading uninitialized memory. Either way, the benchmark
was never constructing semantically correct pixel values for the
VectorImage case.

Introduce a PixelFiller trait that specializes for
VariableLengthVector so the VectorImage branch constructs a
properly sized VLV and Fills it with 'count'. Scalar and
FixedArray branches keep the existing static_cast path.

With this change the benchmark produces well-defined output across
the ITK v5.3 -> main range regardless of the internal
representation of VariableLengthVector(0).

Author: hjmjohnson

examples/Core/itkCopyIterationBenchmark.cxx

@@ -33,6 +33,47 @@
 #include <fstream>
 
 
+// Pixel-construction traits.
+//
+// For scalar and FixedArray-backed images, `static_cast<PixelType>(count)`
+// produces a pixel whose value encodes `count`. For VectorImage, whose
+// PixelType is `itk::VariableLengthVector<T>`, the single-argument
+// constructor is a LENGTH constructor — `VLV<float>(count)` yields a
+// vector of size `count`, not a multi-component pixel with value `count`.
+// Passing that length-mismatched value through the VectorImage pixel
+// accessor used to read out-of-spec memory ("happens to work" prior to
+// ITK commit 1d87efa5) and now segfaults, because the accessor copies
+// exactly `NumberOfComponentsPerPixel` elements from the source's
+// internal data pointer — which is null when the source VLV has size 0.
+//
+// The specialization below constructs a correctly-sized
+// VariableLengthVector pixel, filled with `count` (cast to the value
+// type). This makes the benchmark portable across all ITK versions in
+// the v5.3 → main range regardless of how `VLV(0)` is represented
+// internally.
+template <typename TPixel>
+struct PixelFiller
+{
+  static TPixel
+  Make(unsigned int count, unsigned int /*componentsPerPixel*/)
+  {
+    return static_cast<TPixel>(count);
+  }
+};
+
+template <typename TValue>
+struct PixelFiller<itk::VariableLengthVector<TValue>>
+{
+  static itk::VariableLengthVector<TValue>
+  Make(unsigned int count, unsigned int componentsPerPixel)
+  {
+    itk::VariableLengthVector<TValue> pixel(componentsPerPixel);
+    pixel.Fill(static_cast<TValue>(count));
+    return pixel;
+  }
+};
+
+
 // Helper function to initialize an image with random values
 template <typename TImage>
 typename TImage::Pointer
@@ -54,7 +95,7 @@ CreateAndInitializeImage(const typename TImage::SizeType & size, unsigned int nu
   itk::ImageRegionIterator<TImage> it(image, region);
   for (; !it.IsAtEnd(); ++it)
   {
-    it.Set(static_cast<PixelType>(count));
+    it.Set(PixelFiller<PixelType>::Make(count, numberOfComponentsPerPixel));
     ++count;
   }