diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.cpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.cpp
index 707fe34b05..d43ef391f3 100644
--- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.cpp
+++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.cpp
@@ -6,6 +6,20 @@
 
 using namespace nx::core;
 
+DataType ITK::detail::ConvertChoiceToDataType(types::usize choice)
+{
+  switch(choice)
+  {
+  case 0:
+    return DataType::uint8;
+  case 1:
+    return DataType::uint16;
+  case 2:
+    return DataType::uint32;
+  }
+  return DataType::uint8;
+}
+
 bool ITK::DoTuplesMatch(const IDataStore& dataStore, const ImageGeom& imageGeom)
 {
   return imageGeom.getNumberOfCells() == dataStore.getNumberOfTuples();
diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.hpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.hpp
index e3baba6a5f..d98190317e 100644
--- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.hpp
+++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ITKArrayHelper.hpp
@@ -29,6 +29,45 @@
 
 namespace nx::core::ITK
 {
+namespace detail
+{
+template <typename OriginT>
+struct TypeConversionValidateFunctor
+{
+  template <typename DestT>
+  bool operator()()
+  {
+    if constexpr(std::is_same_v<OriginT, DestT>)
+    {
+      // This won't actually fail, but it prevents an unnecessary copy
+      return false;
+    }
+    if constexpr(std::is_signed_v<OriginT> || std::is_signed_v<DestT>)
+    {
+      return false;
+    }
+    if constexpr(std::is_same_v<OriginT, bool> || std::is_same_v<DestT, bool>)
+    {
+      return false;
+    }
+
+    // Currently only works on uint8, uint16, or uint32
+    return true;
+  }
+};
+
+struct PreflightTypeConversionValidateFunctor
+{
+  template <typename OriginT>
+  bool operator()(const DataType& destType)
+  {
+    return ExecuteNeighborFunction(TypeConversionValidateFunctor<OriginT>{}, destType);
+  }
+};
+
+DataType ConvertChoiceToDataType(usize choice);
+} // namespace detail
+
 struct ImageGeomData
 {
   SizeVec3 dims{};
@@ -344,11 +383,11 @@ DataStore<UnderlyingType_t<PixelT>> ConvertImageToDataStore(itk::Image<PixelT, D
   return dataStore;
 }
 
-template<typename T>
+template <typename T>
 concept NotBoolT = !std::is_same_v<T, bool>;
 
 template <NotBoolT NewStoreT, class PixelT, uint32 Dimension>
-Result<> ConvertImageToDataStore(AbstractDataStore<NewStoreT>& dataStore, itk::Image<PixelT, Dimension>& image)
+Result<> ConvertImageToDataStore(DataStore<NewStoreT>& dataStore, itk::Image<PixelT, Dimension>& image)
 {
   using ImageType = itk::Image<PixelT, Dimension>;
   using T = UnderlyingType_t<PixelT>;
@@ -366,23 +405,19 @@ Result<> ConvertImageToDataStore(AbstractDataStore<NewStoreT>& dataStore, itk::I
   pixelContainer->ContainerManageMemoryOff();
   if constexpr(std::is_same_v<NewStoreT, T>)
   {
-    std::unique_ptr<T[]> newData(rawBufferPtr);
-    dataStore = DataStore<T>(std::move(newData), std::move(tDims), std::move(cDims));
+    std::copy(rawBufferPtr, rawBufferPtr + pixelContainer->Size(), dataStore.data());
   }
   else
   {
-    std::unique_ptr<NewStoreT[]> newData = std::make_unique<NewStoreT[]>(sizeof(NewStoreT) * pixelContainer->Size());
     if constexpr(!std::is_signed_v<NewStoreT> && !std::is_signed_v<T>) // bool would slip through, but it is disallowed
     {
       constexpr auto destMaxV = static_cast<float64>(std::numeric_limits<NewStoreT>::max());
       constexpr auto originMaxV = std::numeric_limits<T>::max();
-      std::transform(rawBufferPtr, rawBufferPtr + pixelContainer->Size(), newData.get(), [](auto value) {
+      std::transform(rawBufferPtr, rawBufferPtr + pixelContainer->Size(), dataStore.data(), [](auto value) {
         float64 ratio = static_cast<float64>(value) / originMaxV;
         return static_cast<NewStoreT>(ratio * destMaxV);
       });
     }
-
-    dataStore = DataStore<NewStoreT>(std::move(newData), std::move(tDims), std::move(cDims));
   }
 
   return {};
@@ -394,7 +429,7 @@ struct ConvertImageToDatastoreFunctor
   Result<> operator()(DataStructure& dataStructure, const DataPath& arrayPath, Args&&... args)
   {
     auto& dataArray = dataStructure.getDataRefAs<DataArray<T>>(arrayPath);
-    auto& dataStore = dataArray.template getIDataStoreRefAs<DataStore<T>>();
+    DataStore<T>& dataStore = dataArray.template getIDataStoreRefAs<DataStore<T>>();
 
     return ConvertImageToDataStore(dataStore, std::forward<Args>(args)...);
   }
@@ -881,4 +916,4 @@ Result<detail::ITKFilterFunctorResult_t<FilterCreationFunctorT>> Execute(DataStr
     return MakeErrorResult<ResultT>(-222, exception.GetDescription());
   }
 }
-} // namespace nx::core
+} // namespace nx::core::ITK
diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.cpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.cpp
index f583efb6dd..ad673618e5 100644
--- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.cpp
+++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.cpp
@@ -80,7 +80,7 @@ Result<OutputActions> ReadImagePreflight(const std::string& fileName, DataPath i
     actions.appendAction(std::make_unique<CreateImageGeometryAction>(std::move(imageGeomPath), std::move(dims), origin.toContainer<CreateImageGeometryAction::OriginType>(),
                                                                      spacing.toContainer<CreateImageGeometryAction::SpacingType>(), cellDataName));
 
-    if(imageReaderOptions.ChangeDataType)
+    if(imageReaderOptions.ChangeDataType && ExecuteNeighborFunction(ITK::detail::PreflightTypeConversionValidateFunctor{}, *numericType, imageReaderOptions.ImageDataType))
     {
       actions.appendAction(
           std::make_unique<CreateArrayAction>(imageReaderOptions.ImageDataType, std::move(arrayDims), std::move(cDims), imageGeomPath.createChildPath(cellDataName).createChildPath(arrayName)));
diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.hpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.hpp
index e69a5fc827..15c5b83839 100644
--- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.hpp
+++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Common/ReadImageUtils.hpp
@@ -2,8 +2,8 @@
 
 #include "simplnx/Common/Result.hpp"
 #include "simplnx/Common/Types.hpp"
-#include "simplnx/Utilities/FilterUtilities.hpp"
 #include "simplnx/Filter/Actions/CreateImageGeometryAction.hpp"
+#include "simplnx/Utilities/FilterUtilities.hpp"
 
 #include "ITKImageProcessing/Common/ITKArrayHelper.hpp"
 
@@ -58,13 +58,20 @@ struct ReadImageIntoArrayFunctor
     using ImageType = itk::Image<PixelT, Dimension>;
     using ReaderType = itk::ImageFileReader<ImageType>;
 
+    if(!ExecuteNeighborFunction(ITK::detail::TypeConversionValidateFunctor<typename itk::NumericTraits<PixelT>::ValueType>{}, dataType))
+    {
+      // Not valid for conversion executing overload
+      return operator()<PixelT, Dimension>(dataStructure, arrayPath, filePath);
+    }
+
     typename ReaderType::Pointer reader = ReaderType::New();
     reader->SetFileName(filePath);
 
     reader->Update();
     typename ImageType::Pointer outputImage = reader->GetOutput();
 
-    return ExecuteNeighborFunction(ITK::ConvertImageToDatastoreFunctor{}, dataType, dataStructure, arrayPath, *outputImage);;
+    return ExecuteNeighborFunction(ITK::ConvertImageToDatastoreFunctor{}, dataType, dataStructure, arrayPath, *outputImage);
+    ;
   }
 };
 
diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImageReaderFilter.cpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImageReaderFilter.cpp
index b8cf05f53e..f5ca3c511c 100644
--- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImageReaderFilter.cpp
+++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImageReaderFilter.cpp
@@ -21,23 +21,6 @@ namespace fs = std::filesystem;
 
 using namespace nx::core;
 
-namespace
-{
-DataType ConvertChoiceToDataType(ChoicesParameter::ValueType choice)
-{
-  switch(choice)
-  {
-  case 0:
-    return DataType::uint8;
-  case 1:
-    return DataType::uint16;
-  case 2:
-    return DataType::uint32;
-  }
-  return DataType::uint8;
-}
-} // namespace
-
 namespace nx::core
 {
 //------------------------------------------------------------------------------
@@ -145,7 +128,7 @@ IFilter::PreflightResult ITKImageReaderFilter::preflightImpl(const DataStructure
   imageReaderOptions.Origin = FloatVec3(static_cast<float32>(origin[0]), static_cast<float32>(origin[1]), static_cast<float32>(origin[2]));
   imageReaderOptions.Spacing = FloatVec3(static_cast<float32>(spacing[0]), static_cast<float32>(spacing[1]), static_cast<float32>(spacing[2]));
   imageReaderOptions.ChangeDataType = pChangeDataType;
-  imageReaderOptions.ImageDataType = ConvertChoiceToDataType(choiceType);
+  imageReaderOptions.ImageDataType = ITK::detail::ConvertChoiceToDataType(choiceType);
 
   Result<OutputActions> result = cxItkImageReaderFilter::ReadImagePreflight(fileNameString, imageGeomPath, cellDataName, imageDataArrayName, imageReaderOptions);
 
@@ -166,7 +149,7 @@ Result<> ITKImageReaderFilter::executeImpl(DataStructure& dataStructure, const A
   auto origin = filterArgs.value<VectorFloat64Parameter::ValueType>(k_Origin_Key);
   auto spacing = filterArgs.value<VectorFloat64Parameter::ValueType>(k_Spacing_Key);
   auto pChangeDataType = filterArgs.value<bool>(k_ChangeDataType_Key);
-  auto newDataType = ConvertChoiceToDataType(filterArgs.value<ChoicesParameter::ValueType>(k_ImageDataType_Key));
+  auto newDataType = ITK::detail::ConvertChoiceToDataType(filterArgs.value<ChoicesParameter::ValueType>(k_ImageDataType_Key));
 
   DataPath imageDataArrayPath = imageGeometryPath.createChildPath(cellDataName).createChildPath(imageDataArrayName);
   const IDataArray* inputArrayPtr = dataStructure.getDataAs<IDataArray>(imageDataArrayPath);
diff --git a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImportImageStackFilter.cpp b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImportImageStackFilter.cpp
index 3a73343cb2..245129ea8f 100644
--- a/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImportImageStackFilter.cpp
+++ b/src/Plugins/ITKImageProcessing/src/ITKImageProcessing/Filters/ITKImportImageStackFilter.cpp
@@ -15,6 +15,7 @@
 #include "simplnx/Parameters/DataObjectNameParameter.hpp"
 #include "simplnx/Parameters/GeneratedFileListParameter.hpp"
 #include "simplnx/Parameters/VectorParameter.hpp"
+#include "simplnx/Utilities/FilterUtilities.hpp"
 
 #include <itkImageFileReader.h>
 #include <itkImageIOBase.h>
@@ -133,7 +134,7 @@ namespace cxITKImportImageStackFilter
 template <class T>
 Result<> ReadImageStack(DataStructure& dataStructure, const DataPath& imageGeomPath, const std::string& cellDataName, const std::string& imageArrayName, const std::vector<std::string>& files,
                         ChoicesParameter::ValueType transformType, bool convertToGrayscale, const VectorFloat32Parameter::ValueType& luminosityValues, bool resample, float32 scalingFactor,
-                        const IFilter::MessageHandler& messageHandler, const std::atomic_bool& shouldCancel)
+                        bool changeDataType, ChoicesParameter::ValueType destType, const IFilter::MessageHandler& messageHandler, const std::atomic_bool& shouldCancel)
 {
   auto& imageGeom = dataStructure.getDataRefAs<ImageGeom>(imageGeomPath);
   DataPath imageDataPath = imageGeomPath.createChildPath(cellDataName).createChildPath(imageArrayName);
@@ -172,6 +173,8 @@ Result<> ReadImageStack(DataStructure& dataStructure, const DataPath& imageGeomP
       args.insertOrAssign(ITKImageReaderFilter::k_CellDataName_Key, std::make_any<std::string>(cellDataName));
       args.insertOrAssign(ITKImageReaderFilter::k_ImageDataArrayPath_Key, std::make_any<std::string>(imageArrayName));
       args.insertOrAssign(ITKImageReaderFilter::k_FileName_Key, std::make_any<fs::path>(filePath));
+      args.insertOrAssign(ITKImageReaderFilter::k_ChangeDataType_Key, std::make_any<bool>(changeDataType));
+      args.insertOrAssign(ITKImageReaderFilter::k_ImageDataType_Key, std::make_any<ChoicesParameter::ValueType>(destType));
 
       auto executeResult = imageReader.execute(importedDataStructure, args);
       if(executeResult.result.invalid())
@@ -470,12 +473,7 @@ IFilter::PreflightResult ITKImportImageStackFilter::preflightImpl(const DataStru
                             nx::core::DataTypeToString(createArrayActionPtr->type())));
   }
 
-  if(pChangeDataType)
-  {
-//    auto action = std::make_unique<CreateArrayAction>(ConvertNumericTypeToDataType(numericType), arrayDims, std::vector<size_t>{1ULL}, imageDataPath);
-//    resultOutputActions.value().appendAction(std::move(action));
-  }
-  else if(pConvertToGrayScaleValue)
+  if(pConvertToGrayScaleValue)
   {
     auto* filterListPtr = Application::Instance()->getFilterList();
     if(!filterListPtr->containsPlugin(k_SimplnxCorePluginId))
@@ -514,6 +512,9 @@ Result<> ITKImportImageStackFilter::executeImpl(DataStructure& dataStructure, co
   auto pScaleImagesValue = filterArgs.value<BoolParameter::ValueType>(k_ScaleImages_Key);
   auto pScalingValue = filterArgs.value<Float32Parameter::ValueType>(k_Scaling_Key);
 
+  auto changeDataType = filterArgs.value<bool>(k_ChangeDataType_Key);
+  auto destType = filterArgs.value<ChoicesParameter::ValueType>(k_ImageDataType_Key);
+
   // const DataPath imageDataPath = imageGeomPath.createChildPath(cellDataName).createChildPath(imageDataName);
 
   std::vector<std::string> files = inputFileListInfo.generate();
@@ -531,62 +532,91 @@ Result<> ITKImportImageStackFilter::executeImpl(DataStructure& dataStructure, co
   {
     return MakeErrorResult(-4, fmt::format("Unsupported pixel component: {}", imageIO->GetComponentTypeAsString(component)));
   }
+
   Result<> readResult;
-  switch(*numericType)
+  if(changeDataType &&
+     ExecuteNeighborFunction(nx::core::ITK::detail::PreflightTypeConversionValidateFunctor{}, ConvertNumericTypeToDataType(*numericType), ITK::detail::ConvertChoiceToDataType(destType)))
   {
-  case NumericType::uint8: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<uint8>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                    pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::int8: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<int8>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                   pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::uint16: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<uint16>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                     pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::int16: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<int16>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                    pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::uint32: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<uint32>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                     pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::int32: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<int32>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                    pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::uint64: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<uint64>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                     pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::int64: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<int64>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                    pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::float32: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<float32>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                      pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  case NumericType::float64: {
-    readResult = cxITKImportImageStackFilter::ReadImageStack<float64>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
-                                                                      pScaleImagesValue, pScalingValue, messageHandler, shouldCancel);
-    break;
-  }
-  default: {
-    throw std::runtime_error("Unsupported array type");
+    switch(ITK::detail::ConvertChoiceToDataType(destType))
+    {
+    case DataType::uint8: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<uint8>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
+                                                                      pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case DataType::uint16: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<uint16>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue,
+                                                                       colorWeightsValue, pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case DataType::uint32: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<uint32>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue,
+                                                                       colorWeightsValue, pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    default: {
+      throw std::runtime_error("Unsupported Conversion type");
+    }
+    }
   }
+  else
+  {
+    switch(*numericType)
+    {
+    case NumericType::uint8: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<uint8>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
+                                                                      pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::int8: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<int8>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
+                                                                     pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::uint16: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<uint16>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue,
+                                                                       colorWeightsValue, pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::int16: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<int16>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
+                                                                      pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::uint32: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<uint32>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue,
+                                                                       colorWeightsValue, pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::int32: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<int32>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
+                                                                      pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::uint64: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<uint64>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue,
+                                                                       colorWeightsValue, pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::int64: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<int64>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue, colorWeightsValue,
+                                                                      pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::float32: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<float32>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue,
+                                                                        colorWeightsValue, pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    case NumericType::float64: {
+      readResult = cxITKImportImageStackFilter::ReadImageStack<float64>(dataStructure, imageGeomPath, cellDataName, imageDataName, files, imageTransformValue, convertToGrayScaleValue,
+                                                                        colorWeightsValue, pScaleImagesValue, pScalingValue, changeDataType, destType, messageHandler, shouldCancel);
+      break;
+    }
+    default: {
+      throw std::runtime_error("Unsupported array type");
+    }
+    }
   }
 
   return readResult;