From 6ff3b19ee6120edf015fad8caab2991faa3070af Mon Sep 17 00:00:00 2001 From: Anthony Barbier Date: Mon, 4 Sep 2017 18:44:23 +0100 Subject: COMPMID-344 Updated doxygen Change-Id: I32f7b84daa560e460b77216add529c8fa8b327ae --- src/core/CPP/kernels/CPPCornerCandidatesKernel.cpp | 110 +++++++++++++++++++ ...PPDetectionWindowNonMaximaSuppressionKernel.cpp | 120 +++++++++++++++++++++ .../CPP/kernels/CPPSortEuclideanDistanceKernel.cpp | 115 ++++++++++++++++++++ 3 files changed, 345 insertions(+) create mode 100644 src/core/CPP/kernels/CPPCornerCandidatesKernel.cpp create mode 100644 src/core/CPP/kernels/CPPDetectionWindowNonMaximaSuppressionKernel.cpp create mode 100644 src/core/CPP/kernels/CPPSortEuclideanDistanceKernel.cpp (limited to 'src/core/CPP/kernels') diff --git a/src/core/CPP/kernels/CPPCornerCandidatesKernel.cpp b/src/core/CPP/kernels/CPPCornerCandidatesKernel.cpp new file mode 100644 index 0000000000..884da2861b --- /dev/null +++ b/src/core/CPP/kernels/CPPCornerCandidatesKernel.cpp @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2017 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include "arm_compute/core/CPP/kernels/CPPCornerCandidatesKernel.h" + +#include "arm_compute/core/Coordinates.h" +#include "arm_compute/core/Error.h" +#include "arm_compute/core/Helpers.h" +#include "arm_compute/core/IAccessWindow.h" +#include "arm_compute/core/TensorInfo.h" +#include "arm_compute/core/Types.h" +#include "arm_compute/core/Utils.h" +#include "arm_compute/core/Validate.h" +#include "arm_compute/core/Window.h" + +using namespace arm_compute; + +namespace +{ +inline void check_corner(float x, float y, float strength, InternalKeypoint *output, int32_t *num_corner_candidates, std::mutex *corner_candidates_mutex) +{ + if(strength != 0.0f) + { + /* Set index and update num_corner_candidate */ + std::unique_lock lock(*corner_candidates_mutex); + + const int32_t idx = *num_corner_candidates; + + *num_corner_candidates += 1; + + lock.unlock(); + + /* Add keypoint */ + output[idx] = std::make_tuple(x, y, strength); + } +} + +inline void corner_candidates(const float *__restrict input, InternalKeypoint *__restrict output, int32_t x, int32_t y, int32_t *num_corner_candidates, std::mutex *corner_candidates_mutex) +{ + check_corner(x + 0, y, *(input + 0), output, num_corner_candidates, corner_candidates_mutex); + check_corner(x + 1, y, *(input + 1), output, num_corner_candidates, corner_candidates_mutex); + check_corner(x + 2, y, *(input + 2), output, num_corner_candidates, corner_candidates_mutex); + check_corner(x + 3, y, *(input + 3), output, num_corner_candidates, corner_candidates_mutex); +} +} // namespace + +bool keypoint_compare(const InternalKeypoint &lhs, const InternalKeypoint &rhs) +{ + return std::get<2>(lhs) > std::get<2>(rhs); +} + +CPPCornerCandidatesKernel::CPPCornerCandidatesKernel() + : _num_corner_candidates(nullptr), _corner_candidates_mutex(), _input(nullptr), _output(nullptr) +{ +} + +void CPPCornerCandidatesKernel::configure(const IImage *input, InternalKeypoint *output, int32_t *num_corner_candidates) +{ + ARM_COMPUTE_ERROR_ON_TENSOR_NOT_2D(input); + ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F32); + ARM_COMPUTE_ERROR_ON(nullptr == output); + ARM_COMPUTE_ERROR_ON(nullptr == num_corner_candidates); + ARM_COMPUTE_ERROR_ON(*num_corner_candidates != 0); + + _input = input; + _output = output; + _num_corner_candidates = num_corner_candidates; + + const unsigned int num_elems_processed_per_iteration = 4; + + // Configure kernel window + Window win = calculate_max_window(*input->info(), Steps(num_elems_processed_per_iteration)); + + update_window_and_padding(win, AccessWindowHorizontal(input->info(), 0, num_elems_processed_per_iteration)); + + INEKernel::configure(win); +} + +void CPPCornerCandidatesKernel::run(const Window &window) +{ + ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this); + ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window); + Iterator input(_input, window); + + execute_window_loop(window, [&](const Coordinates & id) + { + corner_candidates(reinterpret_cast(input.ptr()), &_output[0], id.x(), id.y(), _num_corner_candidates, &_corner_candidates_mutex); + }, + input); +} diff --git a/src/core/CPP/kernels/CPPDetectionWindowNonMaximaSuppressionKernel.cpp b/src/core/CPP/kernels/CPPDetectionWindowNonMaximaSuppressionKernel.cpp new file mode 100644 index 0000000000..62bfdd60ba --- /dev/null +++ b/src/core/CPP/kernels/CPPDetectionWindowNonMaximaSuppressionKernel.cpp @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2017 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include "arm_compute/core/CPP/kernels/CPPDetectionWindowNonMaximaSuppressionKernel.h" + +#include "arm_compute/core/Error.h" +#include "arm_compute/core/Helpers.h" + +#include +#include + +using namespace arm_compute; + +namespace +{ +bool compare_detection_window(const DetectionWindow &lhs, const DetectionWindow &rhs) +{ + return lhs.score > rhs.score; +} +} // namespace + +CPPDetectionWindowNonMaximaSuppressionKernel::CPPDetectionWindowNonMaximaSuppressionKernel() + : _input_output(nullptr), _min_distance(0.0f) +{ +} + +bool CPPDetectionWindowNonMaximaSuppressionKernel::is_parallelisable() const +{ + return false; +} + +void CPPDetectionWindowNonMaximaSuppressionKernel::configure(IDetectionWindowArray *input_output, float min_distance) +{ + ARM_COMPUTE_ERROR_ON(nullptr == input_output); + + _input_output = input_output; + _min_distance = min_distance; + + IKernel::configure(Window()); // Default 1 iteration window +} + +void CPPDetectionWindowNonMaximaSuppressionKernel::run(const Window &window) +{ + ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this); + ARM_COMPUTE_ERROR_ON_MISMATCHING_WINDOWS(IKernel::window(), window); + ARM_COMPUTE_ERROR_ON(_input_output->buffer() == nullptr); + + const size_t num_candidates = _input_output->num_values(); + size_t num_detections = 0; + + // Sort list of candidates + std::sort(_input_output->buffer(), _input_output->buffer() + num_candidates, compare_detection_window); + + const float min_distance_pow2 = _min_distance * _min_distance; + + // Euclidean distance + for(size_t i = 0; i < num_candidates; ++i) + { + if(0.0f != _input_output->at(i).score) + { + DetectionWindow cur; + cur.x = _input_output->at(i).x; + cur.y = _input_output->at(i).y; + cur.width = _input_output->at(i).width; + cur.height = _input_output->at(i).height; + cur.idx_class = _input_output->at(i).idx_class; + cur.score = _input_output->at(i).score; + + // Store window + _input_output->at(num_detections) = cur; + + ++num_detections; + + const float xc = cur.x + cur.width * 0.5f; + const float yc = cur.y + cur.height * 0.5f; + + for(size_t k = i + 1; k < num_candidates; ++k) + { + const float xn = _input_output->at(k).x + _input_output->at(k).width * 0.5f; + const float yn = _input_output->at(k).y + _input_output->at(k).height * 0.5f; + + const float dx = std::fabs(xn - xc); + const float dy = std::fabs(yn - yc); + + if(dx < _min_distance && dy < _min_distance) + { + const float d = dx * dx + dy * dy; + + if(d < min_distance_pow2) + { + // Invalidate keypoint + _input_output->at(k).score = 0.0f; + } + } + } + } + } + + _input_output->resize(num_detections); +} diff --git a/src/core/CPP/kernels/CPPSortEuclideanDistanceKernel.cpp b/src/core/CPP/kernels/CPPSortEuclideanDistanceKernel.cpp new file mode 100644 index 0000000000..09d3ccffa4 --- /dev/null +++ b/src/core/CPP/kernels/CPPSortEuclideanDistanceKernel.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2017 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include "arm_compute/core/CPP/kernels/CPPSortEuclideanDistanceKernel.h" + +#include "arm_compute/core/Coordinates.h" +#include "arm_compute/core/Error.h" +#include "arm_compute/core/Helpers.h" +#include "arm_compute/core/TensorInfo.h" +#include "arm_compute/core/Types.h" +#include "arm_compute/core/Utils.h" +#include "arm_compute/core/Validate.h" +#include "arm_compute/core/Window.h" + +#include + +using namespace arm_compute; + +namespace +{ +bool keypoint_compare(const InternalKeypoint &lhs, const InternalKeypoint &rhs) +{ + return std::get<2>(lhs) > std::get<2>(rhs); +} +} // namespace + +CPPSortEuclideanDistanceKernel::CPPSortEuclideanDistanceKernel() + : _num_corner_candidates(), _min_distance(0.0f), _in_out(nullptr), _output(nullptr) +{ +} + +void CPPSortEuclideanDistanceKernel::configure(InternalKeypoint *in_out, IKeyPointArray *output, const int32_t *num_corner_candidates, float min_distance) +{ + ARM_COMPUTE_ERROR_ON(nullptr == in_out); + ARM_COMPUTE_ERROR_ON(nullptr == output); + ARM_COMPUTE_ERROR_ON(nullptr == num_corner_candidates); + ARM_COMPUTE_ERROR_ON(!((min_distance > 0) && (min_distance <= 30))); + + _in_out = in_out; + _output = output; + _min_distance = min_distance * min_distance; // We compare squares of distances + _num_corner_candidates = num_corner_candidates; + ICPPKernel::configure(Window()); // Default 1 iteration window +} + +bool CPPSortEuclideanDistanceKernel::is_parallelisable() const +{ + return false; +} + +void CPPSortEuclideanDistanceKernel::run(const Window &window) +{ + ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this); + ARM_COMPUTE_ERROR_ON_MISMATCHING_WINDOWS(ICPPKernel::window(), window); + + const int32_t num_corner_candidates = *_num_corner_candidates; + + /* Sort list of corner candidates */ + std::sort(_in_out, _in_out + num_corner_candidates, keypoint_compare); + + /* Euclidean distance */ + for(int32_t i = 0; i < num_corner_candidates; ++i) + { + if(std::get<2>(_in_out[i]) != 0.0f) + { + KeyPoint keypt; + const auto xc = std::get<0>(_in_out[i]); + const auto yc = std::get<1>(_in_out[i]); + + keypt.x = xc; + keypt.y = yc; + keypt.strength = std::get<2>(_in_out[i]); + keypt.tracking_status = 1; + + /* Store corner */ + _output->push_back(keypt); + for(int32_t k = i + 1; k < num_corner_candidates; ++k) + { + const float dx = std::fabs(std::get<0>(_in_out[k]) - xc); + const float dy = std::fabs(std::get<1>(_in_out[k]) - yc); + + if((dx < _min_distance) && (dy < _min_distance)) + { + const float d = (dx * dx + dy * dy); + + if(d < _min_distance) + { + /* Invalidate keypoint */ + std::get<2>(_in_out[k]) = 0.0f; + } + } + } + } + } +} -- cgit v1.2.1