From c6f9510bcb754afaadfe9477ff85d6c55ffcf43b Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Tue, 30 Mar 2021 10:03:01 +0100 Subject: Remove Computer Vision generic interfaces and types Removes: - reference validation routines - CV related types and structures - CV related interfaces Signed-off-by: Georgios Pinitas Change-Id: I3a203da12d9b04c154059b190aeba18a611149a9 Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/5340 Tested-by: Arm Jenkins Reviewed-by: Michele Di Giorgio Comments-Addressed: Arm Jenkins --- arm_compute/core/Utils.h | 201 ----------------------------------------------- 1 file changed, 201 deletions(-) (limited to 'arm_compute/core/Utils.h') diff --git a/arm_compute/core/Utils.h b/arm_compute/core/Utils.h index 19ed73781e..d5c365e6ab 100644 --- a/arm_compute/core/Utils.h +++ b/arm_compute/core/Utils.h @@ -655,82 +655,6 @@ inline bool has_format_vertical_subsampling(Format format) return (format == Format::NV12 || format == Format::NV21 || format == Format::IYUV || format == Format::UV88) ? true : false; } -/** Separate a 2D convolution into two 1D convolutions - * - * @param[in] conv 2D convolution - * @param[out] conv_col 1D vertical convolution - * @param[out] conv_row 1D horizontal convolution - * @param[in] size Size of the 2D convolution - * - * @return true if the separation was successful - */ -inline bool separate_matrix(const int16_t *conv, int16_t *conv_col, int16_t *conv_row, uint8_t size) -{ - int32_t min_col = -1; - int16_t min_col_val = -1; - - for(int32_t i = 0; i < size; ++i) - { - if(conv[i] != 0 && (min_col < 0 || abs(min_col_val) > abs(conv[i]))) - { - min_col = i; - min_col_val = conv[i]; - } - } - - if(min_col < 0) - { - return false; - } - - for(uint32_t j = 0; j < size; ++j) - { - conv_col[j] = conv[min_col + j * size]; - } - - for(uint32_t i = 0; i < size; i++) - { - if(static_cast(i) == min_col) - { - conv_row[i] = 1; - } - else - { - int16_t coeff = conv[i] / conv[min_col]; - - for(uint32_t j = 1; j < size; ++j) - { - if(conv[i + j * size] != (conv_col[j] * coeff)) - { - return false; - } - } - - conv_row[i] = coeff; - } - } - - return true; -} - -/** Calculate the scale of the given square matrix - * - * The scale is the absolute value of the sum of all the coefficients in the matrix. - * - * @note If the coefficients add up to 0 then the scale is set to 1. - * - * @param[in] matrix Matrix coefficients - * @param[in] matrix_size Number of elements per side of the square matrix. (Number of coefficients = matrix_size * matrix_size). - * - * @return The absolute value of the sum of the coefficients if they don't add up to 0, otherwise 1. - */ -inline uint32_t calculate_matrix_scale(const int16_t *matrix, unsigned int matrix_size) -{ - const size_t size = matrix_size * matrix_size; - - return std::max(1, std::abs(std::accumulate(matrix, matrix + size, 0))); -} - /** Adjust tensor shape size if width or height are odd for a given multi-planar format. No modification is done for other formats. * * @note Adding here a few links discussing the issue of odd size and sharing the same solution: @@ -794,117 +718,6 @@ inline TensorShape calculate_subsampled_shape(const TensorShape &shape, Format f return output; } -/** Calculate accurary required by the horizontal and vertical convolution computations - * - * @param[in] conv_col Pointer to the vertical vector of the separated convolution filter - * @param[in] conv_row Pointer to the horizontal vector of the convolution filter - * @param[in] size Number of elements per vector of the separated matrix - * - * @return The return type is a pair. The first element of the pair is the biggest data type needed for the first stage. The second - * element of the pair is the biggest data type needed for the second stage. - */ -inline std::pair data_type_for_convolution(const int16_t *conv_col, const int16_t *conv_row, size_t size) -{ - DataType first_stage = DataType::UNKNOWN; - DataType second_stage = DataType::UNKNOWN; - - auto gez = [](const int16_t &v) - { - return v >= 0; - }; - - auto accu_neg = [](const int &first, const int &second) - { - return first + (second < 0 ? second : 0); - }; - - auto accu_pos = [](const int &first, const int &second) - { - return first + (second > 0 ? second : 0); - }; - - const bool only_positive_coefficients = std::all_of(conv_row, conv_row + size, gez) && std::all_of(conv_col, conv_col + size, gez); - - if(only_positive_coefficients) - { - const int max_row_value = std::accumulate(conv_row, conv_row + size, 0) * UINT8_MAX; - const int max_value = std::accumulate(conv_col, conv_col + size, 0) * max_row_value; - - first_stage = (max_row_value <= UINT16_MAX) ? DataType::U16 : DataType::S32; - - second_stage = (max_value <= UINT16_MAX) ? DataType::U16 : DataType::S32; - } - else - { - const int min_row_value = std::accumulate(conv_row, conv_row + size, 0, accu_neg) * UINT8_MAX; - const int max_row_value = std::accumulate(conv_row, conv_row + size, 0, accu_pos) * UINT8_MAX; - const int neg_coeffs_sum = std::accumulate(conv_col, conv_col + size, 0, accu_neg); - const int pos_coeffs_sum = std::accumulate(conv_col, conv_col + size, 0, accu_pos); - const int min_value = neg_coeffs_sum * max_row_value + pos_coeffs_sum * min_row_value; - const int max_value = neg_coeffs_sum * min_row_value + pos_coeffs_sum * max_row_value; - - first_stage = ((INT16_MIN <= min_row_value) && (max_row_value <= INT16_MAX)) ? DataType::S16 : DataType::S32; - - second_stage = ((INT16_MIN <= min_value) && (max_value <= INT16_MAX)) ? DataType::S16 : DataType::S32; - } - - return std::make_pair(first_stage, second_stage); -} - -/** Calculate the accuracy required by the squared convolution calculation. - * - * - * @param[in] conv Pointer to the squared convolution matrix - * @param[in] size The total size of the convolution matrix - * - * @return The return is the biggest data type needed to do the convolution - */ -inline DataType data_type_for_convolution_matrix(const int16_t *conv, size_t size) -{ - auto gez = [](const int16_t v) - { - return v >= 0; - }; - - const bool only_positive_coefficients = std::all_of(conv, conv + size, gez); - - if(only_positive_coefficients) - { - const int max_conv_value = std::accumulate(conv, conv + size, 0) * UINT8_MAX; - if(max_conv_value <= UINT16_MAX) - { - return DataType::U16; - } - else - { - return DataType::S32; - } - } - else - { - const int min_value = std::accumulate(conv, conv + size, 0, [](int a, int b) - { - return b < 0 ? a + b : a; - }) - * UINT8_MAX; - - const int max_value = std::accumulate(conv, conv + size, 0, [](int a, int b) - { - return b > 0 ? a + b : a; - }) - * UINT8_MAX; - - if((INT16_MIN <= min_value) && (INT16_MAX >= max_value)) - { - return DataType::S16; - } - else - { - return DataType::S32; - } - } -} - /** Permutes the given dimensions according the permutation vector * * @param[in,out] dimensions Dimensions to be permuted. @@ -1024,13 +837,6 @@ const std::string &string_from_data_layout(DataLayout dl); * @return The string describing the data type. */ const std::string &string_from_data_type(DataType dt); -/** Convert a matrix pattern into a string. - * - * @param[in] pattern @ref MatrixPattern to be translated to string. - * - * @return The string describing the matrix pattern. - */ -const std::string &string_from_matrix_pattern(MatrixPattern pattern); /** Translates a given activation function to a string. * * @param[in] act @ref ActivationLayerInfo::ActivationFunction to be translated to string. @@ -1038,13 +844,6 @@ const std::string &string_from_matrix_pattern(MatrixPattern pattern); * @return The string describing the activation function. */ const std::string &string_from_activation_func(ActivationLayerInfo::ActivationFunction act); -/** Translates a given non linear function to a string. - * - * @param[in] function @ref NonLinearFilterFunction to be translated to string. - * - * @return The string describing the non linear function. - */ -const std::string &string_from_non_linear_filter_function(NonLinearFilterFunction function); /** Translates a given interpolation policy to a string. * * @param[in] policy @ref InterpolationPolicy to be translated to string. -- cgit v1.2.1