Function sam2_window_unpartition

sam3.cpp:4244–4281

Window unpartition: reverse of sam2_window_partition. Input ne = {C, ws, ws, nW*B}, output ne = {C, orig_W, orig_H, B}. Reverses the partition steps: 1. Reshape [C, ws, ws, nW*B] -> [C*ws, ws, nW_h, nW_w*B] 2. Reshape [C*ws, ws, nW_h, nW_w*B] -> [C*ws, Hp, nW_w, B] (merge local-H with nW_h) 3. Permute (0,2,1,3) -> [C*ws, nW_w, Hp, B] 4. Cont 5. Reshape [C*ws, nW_w, Hp, B] -> [C, Wp, Hp, B] 6. Cr

//   5. Reshape [C*ws, nW_w, Hp, B] -> [C, Wp, Hp, B]
//   6. Crop to (orig_W, orig_H)
static struct ggml_tensor* sam2_window_unpartition(struct ggml_context* ctx,
                                                    struct ggml_tensor* x,
                                                    int ws, int pad_hw[2],
                                                    int orig_H, int orig_W,
                                                    int B) {
    const int64_t C = x->ne[0];
    int64_t Hp = pad_hw[0];
    int64_t Wp = pad_hw[1];
    int64_t nW_h = Hp / ws;
    int64_t nW_w = Wp / ws;

    // Step 1: Reshape [C, ws, ws, nW*B] -> [C*ws, ws, nW_h, nW_w*B]
    //   Merges (C, local_W=ws) into C*ws; splits nW into (nW_h, nW_w*B).
    auto* r1 = ggml_reshape_4d(ctx, x, C * ws, ws, nW_h, nW_w * B);

    // Step 2: Reshape [C*ws, ws, nW_h, nW_w*B] -> [C*ws, Hp, nW_w, B]
    //   Merges (local_H=ws, nW_h) into Hp=ws*nW_h; splits nW_w*B into (nW_w, B).
    auto* r2 = ggml_reshape_4d(ctx, r1, C * ws, Hp, nW_w, B);

    // Step 3: Permute to [C*ws, nW_w, Hp, B]
    auto* p1 = ggml_permute(ctx, r2, 0, 2, 1, 3);

    // Step 4: Cont
    auto* c1 = ggml_cont(ctx, p1);

    // Step 5: Reshape [C*ws, nW_w, Hp, B] -> [C, Wp, Hp, B]
    //   Splits (C*ws) with nW_w to recover (C, Wp=ws*nW_w).
    auto* out = ggml_reshape_4d(ctx, c1, C, Wp, Hp, B);

    // Step 6: Crop if padded
    if (Hp != orig_H || Wp != orig_W) {
        out = ggml_view_4d(ctx, out, C, orig_W, orig_H, B,
                           out->nb[1], out->nb[2], out->nb[3], 0);
        out = ggml_cont(ctx, out);
    }

    return out;
}

// MaxPool2d with kernel=2, stride=2 on spatial dims (ne[1]=W, ne[2]=H).
// Input: [C, W, H, B] -> output: [C, W/2, H/2, B]