Function TEST_F

dnn/test/naive/warp_perspective.cpp:58–179

}  // namespace

TEST_F(NAIVE, WARP_PERSPECTIVE_MULTI_SRC) {
    using Param = WarpPerspective::Param;

    WarpPerspective::Param param;
    auto extra_impl = [&param, this](const TensorNDArray& tensors) {
        //! split src
        TensorND src = tensors[0];  // n h w c
        size_t n = src.layout[0];
        TensorNDArray srcs;  // n 个 1 h w c
        TensorLayoutArray srcs_layouts;
        for (size_t i = 0; i < n; i++) {
            TensorLayout ly;
            ly = TensorLayout{
                    {1, src.layout[1], src.layout[2], src.layout[3]}, src.layout.dtype};
            srcs.emplace_back(malloc(ly.span().dist_byte()), ly);
            srcs_layouts.emplace_back(ly);
        }

        auto split = handle()->create_operator<SplitForward>();
        split->param().axis = 0;
        auto split_ws_size = split->get_workspace_in_bytes(src.layout, srcs_layouts);
        dt_byte* split_ws_ptr = static_cast<dt_byte*>(malloc(split_ws_size));
        Workspace split_ws{split_ws_ptr, split_ws_size};
        split->exec(src, srcs, split_ws);

        auto warp_perspective = handle()->create_operator<WarpPerspective>();
        warp_perspective->param() = param;
        auto warp_ws_size = warp_perspective->get_workspace_in_bytes(
                srcs_layouts, tensors[1].layout, tensors[2].layout);
        dt_byte* warp_ws_ptr = static_cast<dt_byte*>(malloc(warp_ws_size));
        Workspace warp_ws{warp_ws_ptr, warp_ws_size};
        warp_perspective->exec(srcs, tensors[1], tensors[2], warp_ws);

        free(split_ws_ptr);
        free(warp_ws_ptr);
        for (auto&& s : srcs) {
            free(s.raw_ptr());
        }
    };

    {
        // Float32
        Checker<WarpPerspectiveForward> checker(handle());
        WarpPerspectiveMatRNG rng;
        checker.set_rng(1, &rng);
        checker.set_extra_opr_impl(extra_impl);
        // NHWC
        for (auto bmode :
             {WarpPerspective::BorderMode::WRAP, WarpPerspective::BorderMode::REFLECT,
              WarpPerspective::BorderMode::REPLICATE,
              WarpPerspective::BorderMode::CONSTANT}) {
            param.border_val = 0.3f;
            param.bmode = bmode;
            param.imode = Param::InterpolationMode::LINEAR;

            param.format = Param::Format::NHWC;
            checker.set_param(param);
            checker.execs({{1, 2, 2, 4}, {1, 3, 3}, {1, 2, 2, 4}});