BUG: Use NumPy dtypes for type mapping

Updates Python wrappings and extras to primarily use `np.dtype` objects
for mapping from NumPy to ITK types.

Follows discussion in SimpleITK/SimpleITK#1685
and addresses
#3544 .

Author: tbirdso

Modules/Bridge/NumPy/wrapping/PyBuffer.i.init

@@ -29,29 +29,29 @@ else:
         loads = dask_deserialize.dispatch(np.ndarray)
         return NDArrayITKBase(loads(header, frames))
 
-def _get_numpy_pixelid(itk_Image_type):
+def _get_numpy_pixelid(itk_Image_type) -> np.dtype:
     """Returns a ITK PixelID given a numpy array."""
 
     # This is a Mapping from numpy array types to itk pixel types.
-    _np_itk = {"UC":np.uint8,
-               "US":np.uint16,
-               "UI":np.uint32,
-               "UL":np.uint64,
-               "ULL":np.uint64,
-               "SC":np.int8,
-               "SS":np.int16,
-               "SI":np.int32,
-               "SL":np.int64,
-               "SLL":np.int64,
-               "F":np.float32,
-               "D":np.float64,
-               "PF2":np.float32,
-               "PF3":np.float32,
+    _np_itk = {"UC":np.dtype(np.uint8),
+               "US":np.dtype(np.uint16),
+               "UI":np.dtype(np.uint32),
+               "UL":np.dtype(np.uint64),
+               "ULL":np.dtype(np.uint64),
+               "SC":np.dtype(np.int8),
+               "SS":np.dtype(np.int16),
+               "SI":np.dtype(np.int32),
+               "SL":np.dtype(np.int64),
+               "SLL":np.dtype(np.int64),
+               "F":np.dtype(np.float32),
+               "D":np.dtype(np.float64),
+               "PF2":np.dtype(np.float32),
+               "PF3":np.dtype(np.float32),
                 }
     import os
     if os.name == 'nt':
-        _np_itk['UL'] = np.uint32
-        _np_itk['SL'] = np.int32
+        _np_itk['UL'] = np.dtype(np.uint32)
+        _np_itk['SL'] = np.dtype(np.int32)
     try:
         return _np_itk[itk_Image_type]
     except KeyError as e:

Wrapping/Generators/Python/PyBase/pyBase.i

@@ -566,8 +566,13 @@ str = str
                 import numpy as np
                 from itk.support import types
 
-                # if both a numpy dtype and a ctype exist, use the latter.
+                # Convert numpy type to dtype object for consistency
+                # i.e. <np.float32> -> np.dtype('float32')
                 if type(pixel_type) is type:
+                    pixel_type = np.dtype(pixel_type)
+
+                # if both a numpy dtype and an ITK ctype exist, use the latter.
+                if issubclass(type(pixel_type), np.dtype):
                     c_pixel_type = types.itkCType.GetCTypeForDType(pixel_type)
                     if c_pixel_type is not None:
                         pixel_type = c_pixel_type

Wrapping/Generators/Python/Tests/extras.py

@@ -389,6 +389,10 @@ def custom_callback(name, progress):
 
 # BridgeNumPy
 
+arr = np.zeros([3,4,5],dtype=np.dtype('uintc'))
+image = itk.image_from_array(arr)
+assert itk.template(image)[1] == (itk.UI, 3)
+
 # Images
 
 image = itk.imread(filename)

Wrapping/Generators/Python/itk/support/extras.py

@@ -273,26 +273,23 @@ def _long_type():
 
     # This is a Mapping from numpy array types to itk pixel types.
     _np_itk = {
-        np.uint8: itk.UC,
-        np.uint16: itk.US,
-        np.uint32: itk.UI,
-        np.uint64: _long_type(),
-        np.int8: itk.SC,
-        np.int16: itk.SS,
-        np.int32: itk.SI,
-        np.int64: itk.SL,
-        np.float32: itk.F,
-        np.float64: itk.D,
-        np.complex64: itk.complex[itk.F],
-        np.complex128: itk.complex[itk.D],
+        np.dtype(np.uint8): itk.UC,
+        np.dtype(np.uint16): itk.US,
+        np.dtype(np.uint32): itk.UI,
+        np.dtype(np.uint64): _long_type(),
+        np.dtype(np.int8): itk.SC,
+        np.dtype(np.int16): itk.SS,
+        np.dtype(np.int32): itk.SI,
+        np.dtype(np.int64): itk.SL,
+        np.dtype(np.float32): itk.F,
+        np.dtype(np.float64): itk.D,
+        np.dtype(np.complex64): itk.complex[itk.F],
+        np.dtype(np.complex128): itk.complex[itk.D],
     }
     try:
-        return _np_itk[numpy_array_type.dtype.type]
+        return _np_itk[numpy_array_type.dtype]
     except KeyError as e:
-        for key in _np_itk:
-            if np.issubdtype(numpy_array_type.dtype.type, key):
-                return _np_itk[key]
-            raise e
+        raise e
 
 
 def _GetArrayFromImage(

Wrapping/Generators/Python/itk/support/types.py

@@ -119,28 +119,28 @@ def initialize_c_types_once() -> (
         """
         import numpy as np
 
-        _F: "itkCType" = itkCType("float", "F", np.float32)
-        _D: "itkCType" = itkCType("double", "D", np.float64)
-        _UC: "itkCType" = itkCType("unsigned char", "UC", np.uint8)
-        _US: "itkCType" = itkCType("unsigned short", "US", np.uint16)
-        _UI: "itkCType" = itkCType("unsigned int", "UI", np.uint32)
+        _F: "itkCType" = itkCType("float", "F", np.dtype(np.float32))
+        _D: "itkCType" = itkCType("double", "D", np.dtype(np.float64))
+        _UC: "itkCType" = itkCType("unsigned char", "UC", np.dtype(np.uint8))
+        _US: "itkCType" = itkCType("unsigned short", "US", np.dtype(np.uint16))
+        _UI: "itkCType" = itkCType("unsigned int", "UI", np.dtype(np.uint32))
         if os.name == "nt":
-            _UL: "itkCType" = itkCType("unsigned long", "UL", np.uint32)
-            _SL: "itkCType" = itkCType("signed long", "SL", np.int32)
+            _UL: "itkCType" = itkCType("unsigned long", "UL", np.dtype(np.uint32))
+            _SL: "itkCType" = itkCType("signed long", "SL", np.dtype(np.int32))
             _LD: "itkCType" = itkCType("long double", "LD")
         else:
-            _UL: "itkCType" = itkCType("unsigned long", "UL", np.uint64)
-            _SL: "itkCType" = itkCType("signed long", "SL", np.int64)
+            _UL: "itkCType" = itkCType("unsigned long", "UL", np.dtype(np.uint64))
+            _SL: "itkCType" = itkCType("signed long", "SL", np.dtype(np.int64))
             if hasattr(np, "float128"):
-                _LD: "itkCType" = itkCType("long double", "LD", np.float128)
+                _LD: "itkCType" = itkCType("long double", "LD", np.dtype(np.float128))
             else:
                 _LD: "itkCType" = itkCType("long double", "LD")
-        _ULL: "itkCType" = itkCType("unsigned long long", "ULL", np.uint64)
-        _SC: "itkCType" = itkCType("signed char", "SC", np.int8)
-        _SS: "itkCType" = itkCType("signed short", "SS", np.int16)
-        _SI: "itkCType" = itkCType("signed int", "SI", np.int32)
-        _SLL: "itkCType" = itkCType("signed long long", "SLL", np.int64)
-        _B: "itkCType" = itkCType("bool", "B", np.bool_)
+        _ULL: "itkCType" = itkCType("unsigned long long", "ULL", np.dtype(np.uint64))
+        _SC: "itkCType" = itkCType("signed char", "SC", np.dtype(np.int8))
+        _SS: "itkCType" = itkCType("signed short", "SS", np.dtype(np.int16))
+        _SI: "itkCType" = itkCType("signed int", "SI", np.dtype(np.int32))
+        _SLL: "itkCType" = itkCType("signed long long", "SLL", np.dtype(np.int64))
+        _B: "itkCType" = itkCType("bool", "B", np.dtype(np.bool8))
         return _F, _D, _UC, _US, _UI, _UL, _SL, _LD, _ULL, _SC, _SS, _SI, _SLL, _B