Function computeCandidates

src/api/c/canny.cpp:154–196

}

pair<Array<char>, Array<char>> computeCandidates(const Array<float>& supEdges,
                                                 const float t1,
                                                 const af_canny_threshold ct,
                                                 const float t2) {
    float maxVal =
        getScalar<float>(reduce_all<af_max_t, float, float>(supEdges));
    ;
    auto NUM_BINS = static_cast<unsigned>(maxVal);

    auto lowRatio = createValueArray<float>(supEdges.dims(), t1);

    switch (ct) {  // NOLINT(hicpp-multiway-paths-covered)
        case AF_CANNY_THRESHOLD_AUTO_OTSU: {
            auto T2 = otsuThreshold(supEdges, NUM_BINS, maxVal);
            auto T1 = arithOp<float, af_mul_t>(T2, lowRatio, T2.dims());
            Array<char> weak1 =
                logicOp<float, af_ge_t>(supEdges, T1, supEdges.dims());
            Array<char> weak2 =
                logicOp<float, af_lt_t>(supEdges, T2, supEdges.dims());
            Array<char> weak =
                logicOp<char, af_and_t>(weak1, weak2, weak1.dims());
            Array<char> strong =
                logicOp<float, af_ge_t>(supEdges, T2, supEdges.dims());
            return make_pair(strong, weak);
        };
        default: {
            float minVal =
                getScalar<float>(reduce_all<af_min_t, float, float>(supEdges));
            auto normG = normalize(supEdges, minVal, maxVal);
            auto T2    = createValueArray<float>(supEdges.dims(), t2);
            auto T1    = createValueArray<float>(supEdges.dims(), t1);
            Array<char> weak1 =
                logicOp<float, af_ge_t>(normG, T1, normG.dims());
            Array<char> weak2 =
                logicOp<float, af_lt_t>(normG, T2, normG.dims());
            Array<char> weak =
                logicOp<char, af_and_t>(weak1, weak2, weak1.dims());
            Array<char> strong =
                logicOp<float, af_ge_t>(normG, T2, normG.dims());
            return std::make_pair(strong, weak);
        };
    }
}

template<typename T>
af_array cannyHelper(const Array<T>& in, const float t1,