Remove Computer Vision generic interfaces and types

Removes:
    - reference validation routines
    - CV related types and structures
    - CV related interfaces

Signed-off-by: Georgios Pinitas <georgios.pinitas@arm.com>
Change-Id: I3a203da12d9b04c154059b190aeba18a611149a9
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/5340
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>

1 files changed, 0 insertions, 214 deletions

diff --git a/tests/validation/Validation.h b/tests/validation/Validation.h
index d356f05b70..c2df1c31c0 100644
--- a/tests/validation/Validation.h
+++ b/tests/validation/Validation.h
@@ -267,16 +267,6 @@ void validate(std::vector<unsigned int> classified_labels, std::vector<unsigned
 template <typename T, typename U = AbsoluteTolerance<T>>
 bool validate(T target, T reference, U tolerance = AbsoluteTolerance<T>());
 
-/** Validate key points. */
-template <typename T, typename U, typename V = AbsoluteTolerance<float>>
-void validate_keypoints(T target_first, T target_last, U reference_first, U reference_last, V tolerance = AbsoluteTolerance<float>(),
-                        float allowed_missing_percentage = 5.f, float allowed_mismatch_percentage = 5.f);
-
-/** Validate detection windows. */
-template <typename T, typename U, typename V = AbsoluteTolerance<float>>
-void validate_detection_windows(T target_first, T target_last, U reference_first, U reference_last, V tolerance = AbsoluteTolerance<float>(),
-                                float allowed_missing_percentage = 5.f, float allowed_mismatch_percentage = 5.f);
-
 template <typename T>
 struct compare_base
 {
@@ -687,210 +677,6 @@ void validate_min_max_loc(const MinMaxLocationValues<T> &target, const MinMaxLoc
         ARM_COMPUTE_EXPECT(same_coords != reference.max_loc.end(), framework::LogLevel::ERRORS);
     }
 }
-
-/** Check which keypoints from [first1, last1) are missing in [first2, last2) */
-template <typename T, typename U, typename V>
-std::pair<int64_t, int64_t> compare_keypoints(T first1, T last1, U first2, U last2, V tolerance, bool check_mismatches = true)
-{
-    /* Keypoint (x,y) should have similar strength (within tolerance) and other properties in both reference and target */
-    const auto compare_props_eq = [&](const KeyPoint & lhs, const KeyPoint & rhs)
-    {
-        return compare<V>(lhs.strength, rhs.strength, tolerance)
-               && lhs.tracking_status == rhs.tracking_status
-               && lhs.scale == rhs.scale
-               && lhs.orientation == rhs.orientation
-               && lhs.error == rhs.error;
-    };
-
-    /* Used to sort KeyPoints by coordinates (x, y) */
-    const auto compare_coords_lt = [](const KeyPoint & lhs, const KeyPoint & rhs)
-    {
-        return std::tie(lhs.x, lhs.y) < std::tie(rhs.x, rhs.y);
-    };
-
-    std::sort(first1, last1, compare_coords_lt);
-    std::sort(first2, last2, compare_coords_lt);
-
-    if(check_mismatches)
-    {
-        ARM_COMPUTE_TEST_INFO("Checking for mismatches: ref count = " << std::distance(first1, last1) << " target count = " << std::distance(first2, last2));
-    }
-
-    int64_t num_missing    = 0;
-    int64_t num_mismatches = 0;
-    bool    rest_missing   = false;
-
-    while(first1 != last1)
-    {
-        if(first2 == last2)
-        {
-            rest_missing = true;
-            break;
-        }
-
-        if(compare_coords_lt(*first1, *first2))
-        {
-            ++num_missing;
-            ARM_COMPUTE_TEST_INFO("Key point not found");
-            ARM_COMPUTE_TEST_INFO("keypoint1 = " << *first1++);
-            framework::ARM_COMPUTE_PRINT_INFO();
-        }
-        else
-        {
-            if(!compare_coords_lt(*first2, *first1)) // Equal coordinates
-            {
-                if(check_mismatches && !compare_props_eq(*first1, *first2)) // Check other properties
-                {
-                    ++num_mismatches;
-                    ARM_COMPUTE_TEST_INFO("Mismatching keypoint");
-                    ARM_COMPUTE_TEST_INFO("keypoint1 [ref] = " << *first1);
-                    ARM_COMPUTE_TEST_INFO("keypoint2 [tgt] = " << *first2);
-                    framework::ARM_COMPUTE_PRINT_INFO();
-                }
-                ++first1;
-            }
-            ++first2;
-        }
-    }
-
-    if(rest_missing)
-    {
-        while(first1 != last1)
-        {
-            ++num_missing;
-            ARM_COMPUTE_TEST_INFO("Key point not found");
-            ARM_COMPUTE_TEST_INFO("keypoint1 = " << *first1++);
-            framework::ARM_COMPUTE_PRINT_INFO();
-        }
-    }
-
-    return std::make_pair(num_missing, num_mismatches);
-}
-
-template <typename T, typename U, typename V>
-void validate_keypoints(T target_first, T target_last, U reference_first, U reference_last, V tolerance, float allowed_missing_percentage, float allowed_mismatch_percentage)
-{
-    if(framework::Framework::get().configure_only() && framework::Framework::get().new_fixture_call())
-    {
-        return;
-    }
-
-    const int64_t num_elements_target    = std::distance(target_first, target_last);
-    const int64_t num_elements_reference = std::distance(reference_first, reference_last);
-
-    int64_t num_missing    = 0;
-    int64_t num_mismatches = 0;
-
-    if(num_elements_reference > 0)
-    {
-        std::tie(num_missing, num_mismatches) = compare_keypoints(reference_first, reference_last, target_first, target_last, tolerance);
-
-        const float percent_missing    = static_cast<float>(num_missing) / num_elements_reference * 100.f;
-        const float percent_mismatches = static_cast<float>(num_mismatches) / num_elements_reference * 100.f;
-
-        ARM_COMPUTE_TEST_INFO(num_missing << " keypoints (" << std::fixed << std::setprecision(2) << percent_missing << "%) in ref are missing from target");
-        ARM_COMPUTE_TEST_INFO("Missing (not in tgt): " << num_missing << "/" << num_elements_reference << " = " << std::fixed << std::setprecision(2) << percent_missing
-                              << "% \tMax allowed: " << allowed_missing_percentage << "%");
-        ARM_COMPUTE_EXPECT(percent_missing <= allowed_missing_percentage, framework::LogLevel::ERRORS);
-
-        ARM_COMPUTE_TEST_INFO(num_mismatches << " keypoints (" << std::fixed << std::setprecision(2) << percent_mismatches << "%) mismatched");
-        ARM_COMPUTE_TEST_INFO("Mismatched keypoints: " << num_mismatches << "/" << num_elements_reference << " = " << std::fixed << std::setprecision(2) << percent_mismatches
-                              << "% \tMax allowed: " << allowed_mismatch_percentage << "%");
-        ARM_COMPUTE_EXPECT(percent_mismatches <= allowed_mismatch_percentage, framework::LogLevel::ERRORS);
-    }
-
-    if(num_elements_target > 0)
-    {
-        // Note: no need to check for mismatches a second time (last argument is 'false')
-        std::tie(num_missing, num_mismatches) = compare_keypoints(target_first, target_last, reference_first, reference_last, tolerance, false);
-
-        const float percent_missing = static_cast<float>(num_missing) / num_elements_target * 100.f;
-
-        ARM_COMPUTE_TEST_INFO(num_missing << " keypoints (" << std::fixed << std::setprecision(2) << percent_missing << "%) in target are missing from ref");
-        ARM_COMPUTE_TEST_INFO("Missing (not in ref): " << num_missing << "/" << num_elements_target << " = " << std::fixed << std::setprecision(2) << percent_missing
-                              << "% \tMax allowed: " << allowed_missing_percentage << "%");
-        ARM_COMPUTE_EXPECT(percent_missing <= allowed_missing_percentage, framework::LogLevel::ERRORS);
-    }
-}
-
-/** Check which detection windows from [first1, last1) are missing in [first2, last2) */
-template <typename T, typename U, typename V>
-std::pair<int64_t, int64_t> compare_detection_windows(T first1, T last1, U first2, U last2, V tolerance)
-{
-    int64_t num_missing    = 0;
-    int64_t num_mismatches = 0;
-
-    while(first1 != last1)
-    {
-        const auto window = std::find_if(first2, last2, [&](DetectionWindow window)
-        {
-            return window.x == first1->x && window.y == first1->y && window.width == first1->width && window.height == first1->height && window.idx_class == first1->idx_class;
-        });
-
-        if(window == last2)
-        {
-            ++num_missing;
-            ARM_COMPUTE_TEST_INFO("Detection window not found " << *first1)
-            framework::ARM_COMPUTE_PRINT_INFO();
-        }
-        else
-        {
-            if(!compare<V>(window->score, first1->score, tolerance))
-            {
-                ++num_mismatches;
-                ARM_COMPUTE_TEST_INFO("Mismatching detection window")
-                ARM_COMPUTE_TEST_INFO("detection window 1= " << *first1)
-                ARM_COMPUTE_TEST_INFO("detection window 2= " << *window)
-                framework::ARM_COMPUTE_PRINT_INFO();
-            }
-        }
-
-        ++first1;
-    }
-
-    return std::make_pair(num_missing, num_mismatches);
-}
-
-template <typename T, typename U, typename V>
-void validate_detection_windows(T target_first, T target_last, U reference_first, U reference_last, V tolerance,
-                                float allowed_missing_percentage, float allowed_mismatch_percentage)
-{
-    if(framework::Framework::get().configure_only() && framework::Framework::get().new_fixture_call())
-    {
-        return;
-    }
-
-    const int64_t num_elements_target    = std::distance(target_first, target_last);
-    const int64_t num_elements_reference = std::distance(reference_first, reference_last);
-
-    int64_t num_missing    = 0;
-    int64_t num_mismatches = 0;
-
-    if(num_elements_reference > 0)
-    {
-        std::tie(num_missing, num_mismatches) = compare_detection_windows(reference_first, reference_last, target_first, target_last, tolerance);
-
-        const float percent_missing    = static_cast<float>(num_missing) / num_elements_reference * 100.f;
-        const float percent_mismatches = static_cast<float>(num_mismatches) / num_elements_reference * 100.f;
-
-        ARM_COMPUTE_TEST_INFO(num_missing << " detection windows (" << std::fixed << std::setprecision(2) << percent_missing << "%) are missing in target");
-        ARM_COMPUTE_EXPECT(percent_missing <= allowed_missing_percentage, framework::LogLevel::ERRORS);
-
-        ARM_COMPUTE_TEST_INFO(num_mismatches << " detection windows (" << std::fixed << std::setprecision(2) << percent_mismatches << "%) mismatched");
-        ARM_COMPUTE_EXPECT(percent_mismatches <= allowed_mismatch_percentage, framework::LogLevel::ERRORS);
-    }
-
-    if(num_elements_target > 0)
-    {
-        std::tie(num_missing, num_mismatches) = compare_detection_windows(target_first, target_last, reference_first, reference_last, tolerance);
-
-        const float percent_missing = static_cast<float>(num_missing) / num_elements_target * 100.f;
-
-        ARM_COMPUTE_TEST_INFO(num_missing << " detection windows (" << std::fixed << std::setprecision(2) << percent_missing << "%) are not part of target");
-        ARM_COMPUTE_EXPECT(percent_missing <= allowed_missing_percentage, framework::LogLevel::ERRORS);
-    }
-}
-
 } // namespace validation
 } // namespace test
 } // namespace arm_compute