Enum ImageKind 

#[non_exhaustive]
#[repr(u16)]
pub enum ImageKind {
    InterpolateBilinear2d = 0,
    InterpolateBilinear2dBackward = 1,
    InterpolateNearest2d = 2,
    InterpolateNearest2dBackward = 3,
    InterpolateBicubic2d = 4,
    InterpolateBicubic2dBackward = 5,
    InterpolateTrilinear3d = 6,
    InterpolateTrilinear3dBackward = 7,
    InterpolateLinear1d = 8,
    InterpolateLinear1dBackward = 9,
    InterpolateArea2d = 10,
    InterpolateArea2dBackward = 11,
    GridSample2d = 16,
    GridSample2dBackward = 17,
    AffineGrid2d = 18,
    PixelShuffle = 24,
    PixelUnshuffle = 25,
    RoiAlign = 32,
    RoiAlignBackward = 33,
    RoiPool = 34,
    RoiPoolBackward = 35,
    Nms = 40,
}

Image / spatial-transform op discriminant — Category T from the comprehensive plan.

Stored as u16 in crate::KernelSku::op when category == OpCategory::Image. Phase 9 Category T wires the trailblazer set:

• Self::InterpolateBilinear2d / Self::InterpolateBilinear2dBackward — spatial up/downsample via bilinear interpolation.
• Self::GridSample2d / Self::GridSample2dBackward — sample input at arbitrary normalized coordinates (PyTorch torch.nn.functional.grid_sample, default config: mode='bilinear', padding_mode='zeros', align_corners=false).
• Self::AffineGrid2d — generate a sampling grid from a 2×3 affine matrix (companion to GridSample).
• Self::PixelShuffle / Self::PixelUnshuffle — pure index permutation between [N, C·r², H, W] and [N, C, H·r, W·r]. Each is the other’s backward.
• Self::RoiAlign / Self::RoiAlignBackward — extract fixed- size feature from variable RoIs via bilinear sampling.
• Self::RoiPool / Self::RoiPoolBackward — max-pool variant of RoiAlign (argmax routing on BW).
• Self::Nms — non-max suppression on bounding boxes. Returns a boolean keep mask + count; no BW (set-valued op).

Other interpolation modes (nearest, bicubic, trilinear, linear, area) have discriminants reserved here but the kernels are stubbed Unsupported in the trailblazer.

Trailblazer dtype coverage: f32, f64 for math-bearing ops; pixel_shuffle / pixel_unshuffle additionally cover f16, bf16 (pure layout — dtype-agnostic).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

InterpolateBilinear2d = 0

interpolate(x, mode='bilinear', size=…) — 2-D spatial resample with bilinear weights. Trailblazer wired today.

InterpolateBilinear2dBackward = 1

Gradient of Self::InterpolateBilinear2d — atomic-add of weighted contributions from each output cell to the 4 input cells it bilinearly sampled.

InterpolateNearest2d = 2

interpolate(x, mode='nearest') — reserved.

InterpolateNearest2dBackward = 3

Gradient of Self::InterpolateNearest2d — reserved.

InterpolateBicubic2d = 4

interpolate(x, mode='bicubic') — reserved.

InterpolateBicubic2dBackward = 5

Gradient of Self::InterpolateBicubic2d — reserved.

InterpolateTrilinear3d = 6

interpolate(x, mode='trilinear') — reserved.

InterpolateTrilinear3dBackward = 7

Gradient of Self::InterpolateTrilinear3d — reserved.

InterpolateLinear1d = 8

interpolate(x, mode='linear') — reserved (1-D).

InterpolateLinear1dBackward = 9

Gradient of Self::InterpolateLinear1d — reserved.

InterpolateArea2d = 10

interpolate(x, mode='area') — reserved (adaptive avg pool).

InterpolateArea2dBackward = 11

Gradient of Self::InterpolateArea2d — reserved.

GridSample2d = 16

grid_sample(input, grid) — 2-D bilinear, zeros-pad, align_corners=false. PyTorch defaults.

GridSample2dBackward = 17

Gradient of Self::GridSample2d — atomic-add into dinput

• analytical bilinear coordinate derivatives into dgrid.

AffineGrid2d = 18

affine_grid(theta, size) — generate the normalized sampling grid for a 2×3 affine matrix. Companion to GridSample2d.

PixelShuffle = 24

pixel_shuffle(x, r) — [N, C·r², H, W] → [N, C, H·r, W·r]. Pure index permutation. BW is PixelUnshuffle.

PixelUnshuffle = 25

pixel_unshuffle(x, r) — [N, C, H·r, W·r] → [N, C·r², H, W]. Inverse of PixelShuffle. BW is PixelShuffle.

RoiAlign = 32

roi_align(input, rois, output_size, spatial_scale, sampling_ratio=0, aligned=false). PyTorch convention.

RoiAlignBackward = 33

Gradient of Self::RoiAlign — bilinear-weighted atomic-add into dinput.

RoiPool = 34

roi_pool(input, rois, output_size, spatial_scale) — max-pool variant of RoiAlign. Saves argmax indices for BW.

RoiPoolBackward = 35

Gradient of Self::RoiPool — atomic-add of dout[i, c, h, w] into dinput at the saved argmax cell.

Nms = 40

nms(boxes, scores, iou_threshold) — non-max suppression. Returns a boolean keep mask [num_boxes] and a count scalar. No BW (set-valued op).

Trait Implementations

impl Clone for ImageKind

fn clone(&self) -> ImageKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ImageKind

impl Debug for ImageKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for ImageKind

impl Hash for ImageKind

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ImageKind

fn eq(&self, other: &ImageKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ImageKind