Function sam3_tracker_add_instance

sam3.cpp:12017–12088

}

int sam3_tracker_add_instance(sam3_tracker& tracker, sam3_state& state,
                              const sam3_model& model,
                              const sam3_pvs_params& pvs_params) {
    const int D = model.hparams.neck_dim;
    const int mask_hw = sam3_eff_feat_size(state, model.hparams) * 4;

    // Run PVS to get the segmentation mask
    auto r = sam3_segment_pvs(state, model, pvs_params);
    if (r.detections.empty()) {
        fprintf(stderr, "%s: PVS returned no masks\n", __func__);
        return -1;
    }

    const auto& det = r.detections[0];
    if (det.mask.data.empty()) {
        fprintf(stderr, "%s: PVS mask is empty\n", __func__);
        return -1;
    }

    int inst_id = tracker.next_inst_id++;
    // tracker.frame_index points to the *next* frame to process;
    // the instance is being added on the frame that was just tracked.
    int fi = tracker.frame_index - 1;
    if (fi < 0) fi = 0;

    // Create synthetic 288x288 logits from the binary mask.
    // sam3_encode_memory applies sigmoid then scale/bias, so +6/-6 gives
    // sigmoid values ~0.9975/~0.0025 — practically identical to real logits.
    std::vector<float> synth_logits(mask_hw * mask_hw);
    {
        int mw = det.mask.width, mh = det.mask.height;
        for (int y = 0; y < mask_hw; ++y) {
            int sy = y * mh / mask_hw;
            for (int x = 0; x < mask_hw; ++x) {
                int sx = x * mw / mask_hw;
                synth_logits[y * mask_hw + x] =
                    (det.mask.data[sy * mw + sx] > 127) ? 6.0f : -6.0f;
            }
        }
    }

    // Encode into memory bank
    float obj_score = det.mask.obj_score;
    if (!sam3_encode_memory(tracker, state, model, inst_id,
                            synth_logits.data(), mask_hw, mask_hw,
                            fi, true, obj_score)) {
        fprintf(stderr, "%s: failed to encode memory for instance %d\n", __func__, inst_id);
        return -1;
    }

    // Extract object pointer from the SAM decoder token
    std::vector<float> op(D);
    if (!det.sam_token.empty()) {
        sam3_extract_obj_ptr_cpu(model, det.sam_token.data(), obj_score, op.data());
    } else {
        std::fill(op.begin(), op.end(), 0.0f);
    }
    sam3_store_obj_ptr(tracker, model, inst_id, op.data(), fi);