Function edgeTrackingHysteresis

src/backend/opencl/kernel/canny.hpp:131–175

template<typename T>
void edgeTrackingHysteresis(Param output, const Param strong,
                            const Param weak) {
    using cl::EnqueueArgs;
    using cl::NDRange;
    using std::string;
    using std::vector;

    vector<string> options = {
        DefineKeyValue(T, dtype_traits<T>::getName()),
        DefineKey(EDGE_TRACER),
        DefineKeyValue(SHRD_MEM_HEIGHT, THREADS_X + 2),
        DefineKeyValue(SHRD_MEM_WIDTH, THREADS_Y + 2),
        DefineKeyValue(TOTAL_NUM_THREADS, THREADS_X * THREADS_Y),
    };
    options.emplace_back(getTypeBuildDefinition<T>());

    auto edgeTraceOp =
        common::getKernel("edgeTrackKernel", {{trace_edge_cl_src}},
                          TemplateArgs(TemplateTypename<T>()), options);

    NDRange threads(kernel::THREADS_X, kernel::THREADS_Y);

    // Launch only threads to process non-border pixels
    int blk_x = divup(weak.info.dims[0] - 2, threads[0]);
    int blk_y = divup(weak.info.dims[1] - 2, threads[1]);

    // launch batch * blk_x blocks along x dimension
    NDRange global(blk_x * weak.info.dims[2] * threads[0],
                   blk_y * weak.info.dims[3] * threads[1], 1);

    initEdgeOut<T>(output, strong, weak);

    int notFinished = 1;
    auto dContinue  = memAlloc<T>(sizeof(int));

    while (notFinished > 0) {
        notFinished = 0;
        edgeTraceOp.setFlag(dContinue.get(), &notFinished);
        edgeTraceOp(EnqueueArgs(getQueue(), global, threads), *output.data,
                    output.info, blk_x, blk_y, *dContinue);
        CL_DEBUG_FINISH(getQueue());
        notFinished = edgeTraceOp.getFlag(dContinue.get());
    }
    suppressLeftOver<T>(output);
}
}  // namespace kernel
}  // namespace opencl
}  // namespace arrayfire