Function sam3_roi_align_single

sam3.cpp:7607–7666

CPU-side ROI Align matching torchvision.ops.roi_align behavior. Features in ggml [C, W, H] layout. Box in XYXY format scaled to feature grid coords. Uses sub-sampling matching torchvision's sampling_ratio=0 (auto). Output: [C * roi_size * roi_size] in ggml layout.

// Uses sub-sampling matching torchvision's sampling_ratio=0 (auto).
// Output: [C * roi_size * roi_size] in ggml layout.
static void sam3_roi_align_single(
    const float* feats,  // [C, W, H] ggml layout (C innermost, then W, then H)
    int C, int W_feat, int H_feat,
    float x0, float y0, float x1, float y1,
    int roi_size,
    float* out)  // [C, roi_size, roi_size]
{
    float roi_w = std::max(x1 - x0, 1e-6f);
    float roi_h = std::max(y1 - y0, 1e-6f);
    float bin_w = roi_w / (float)roi_size;
    float bin_h = roi_h / (float)roi_size;

    // Match torchvision sampling_ratio=0: use ceil(bin_size) sub-samples
    int sample_y_count = std::max(1, (int)ceilf(bin_h));
    int sample_x_count = std::max(1, (int)ceilf(bin_w));
    float inv_count = 1.0f / (float)(sample_y_count * sample_x_count);

    auto bilinear_sample = [&](float sx, float sy, int c) -> float {
        // Clamp to [-0.5, W-0.5] then adjust — matching torchvision
        if (sx < -1.0f || sx > (float)W_feat || sy < -1.0f || sy > (float)H_feat)
            return 0.0f;

        sy = std::max(0.0f, sy);
        sx = std::max(0.0f, sx);

        int y_lo = (int)sy;
        int x_lo = (int)sx;
        int y_hi = std::min(y_lo + 1, H_feat - 1);
        int x_hi = std::min(x_lo + 1, W_feat - 1);
        y_lo = std::min(y_lo, H_feat - 1);
        x_lo = std::min(x_lo, W_feat - 1);

        float ly = sy - (float)y_lo;
        float lx = sx - (float)x_lo;

        // ggml layout: feats[c + x * C + y * C * W_feat]
        float v00 = feats[c + x_lo * C + y_lo * C * W_feat];
        float v10 = feats[c + x_hi * C + y_lo * C * W_feat];
        float v01 = feats[c + x_lo * C + y_hi * C * W_feat];
        float v11 = feats[c + x_hi * C + y_hi * C * W_feat];

        return v00 * (1 - ly) * (1 - lx) + v10 * (1 - ly) * lx + v01 * ly * (1 - lx) + v11 * ly * lx;
    };

    for (int ph = 0; ph < roi_size; ++ph) {
        for (int pw = 0; pw < roi_size; ++pw) {
            for (int c = 0; c < C; ++c) {
                float sum = 0.0f;
                for (int iy = 0; iy < sample_y_count; ++iy) {
                    float sy = y0 + bin_h * ((float)ph + ((float)iy + 0.5f) / (float)sample_y_count);
                    for (int ix = 0; ix < sample_x_count; ++ix) {
                        float sx = x0 + bin_w * ((float)pw + ((float)ix + 0.5f) / (float)sample_x_count);
                        sum += bilinear_sample(sx, sy, c);
                    }
                }
                out[c + pw * C + ph * C * roi_size] = sum * inv_count;
            }
        }