From 417d14fe2e5f83a1e17e73d69df2e95bbb1de870 Mon Sep 17 00:00:00 2001 From: John Richardson Date: Tue, 22 May 2018 17:14:50 +0100 Subject: COMPMID-587: Port LaplacianReconstruct to new validation Change-Id: I9f160fb10c7cf59b5a84f4c40a96ce865faca2e9 Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/132346 Tested-by: Jenkins Reviewed-by: Anthony Barbier --- tests/validation/CL/LaplacianReconstruct.cpp | 142 +++++++++++++++++++++ tests/validation/NEON/LaplacianReconstruct.cpp | 142 +++++++++++++++++++++ .../fixtures/LaplacianReconstructFixture.h | 104 +++++++++++++++ .../validation/reference/LaplacianReconstruct.cpp | 69 ++++++++++ tests/validation/reference/LaplacianReconstruct.h | 43 +++++++ 5 files changed, 500 insertions(+) create mode 100644 tests/validation/CL/LaplacianReconstruct.cpp create mode 100644 tests/validation/NEON/LaplacianReconstruct.cpp create mode 100644 tests/validation/fixtures/LaplacianReconstructFixture.h create mode 100644 tests/validation/reference/LaplacianReconstruct.cpp create mode 100644 tests/validation/reference/LaplacianReconstruct.h (limited to 'tests') diff --git a/tests/validation/CL/LaplacianReconstruct.cpp b/tests/validation/CL/LaplacianReconstruct.cpp new file mode 100644 index 0000000000..30079e7d5e --- /dev/null +++ b/tests/validation/CL/LaplacianReconstruct.cpp @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2018 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/Types.h" +#include "arm_compute/runtime/CL/CLPyramid.h" +#include "arm_compute/runtime/CL/functions/CLLaplacianPyramid.h" +#include "arm_compute/runtime/CL/functions/CLLaplacianReconstruct.h" +#include "arm_compute/runtime/Tensor.h" +#include "arm_compute/runtime/TensorAllocator.h" +#include "tests/CL/CLAccessor.h" +#include "tests/datasets/BorderModeDataset.h" +#include "tests/datasets/ShapeDatasets.h" +#include "tests/framework/Asserts.h" +#include "tests/framework/Macros.h" +#include "tests/framework/datasets/Datasets.h" +#include "tests/validation/Validation.h" +#include "tests/validation/fixtures/LaplacianReconstructFixture.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +namespace +{ +const auto small_laplacian_reconstruct_levels = framework::dataset::make("NumLevels", 2, 3); +const auto large_laplacian_reconstruct_levels = framework::dataset::make("NumLevels", 2, 5); + +const auto formats = combine(framework::dataset::make("FormatIn", Format::S16), framework::dataset::make("FormatOut", Format::U8)); + +template +void validate_laplacian_reconstruct(CLTensor &target, const SimpleTensor &reference, BorderMode border_mode, size_t num_levels) +{ + const unsigned int filter_size = 5; + const unsigned int border_size(filter_size / 2); + + BorderSize border(std::pow(border_size, num_levels)); + + // Validate output + ValidRegion valid_region = shape_to_valid_region(reference.shape(), border_mode == BorderMode::UNDEFINED, border); + validate(CLAccessor(target), reference, valid_region); +} +} // namespace + +TEST_SUITE(CL) +TEST_SUITE(LaplacianReconstruct) + +// *INDENT-OFF* +// clang-format off +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine( + concat(datasets::Medium2DShapes(), datasets::Large2DShapes()), + datasets::BorderModes()), + large_laplacian_reconstruct_levels), + shape, border_mode, num_levels) +{ + // Create pyramid info + PyramidInfo pyramid_info(num_levels, SCALE_PYRAMID_HALF, shape, Format::S16); + CLPyramid dst_pyramid{}; + dst_pyramid.init(pyramid_info); + + // Create Tensors + CLTensor src = create_tensor(shape, DataType::U8); + + // The first two dimensions of the output tensor must match the first two + // dimensions of the tensor in the last level of the pyramid + TensorShape dst_shape(shape); + dst_shape.set(0, dst_pyramid.get_pyramid_level(num_levels - 1)->info()->dimension(0)); + dst_shape.set(1, dst_pyramid.get_pyramid_level(num_levels - 1)->info()->dimension(1)); + CLTensor dst = create_tensor(dst_shape, DataType::S16); + + // The dimensions of the reconstruct are the same as the src shape + CLTensor rec_dst = create_tensor(shape, DataType::U8); + + // Create and configure pyramid function + CLLaplacianPyramid laplacian_pyramid; + laplacian_pyramid.configure(&src, &dst_pyramid, &dst, border_mode, 0); + + // Create and configure reconstruct function + CLLaplacianReconstruct laplacian_reconstruct; + laplacian_reconstruct.configure(&dst_pyramid, &dst, &rec_dst, border_mode, 0); + + ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS); + ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS); + + for(size_t level = 0; level < pyramid_info.num_levels(); ++level) + { + ARM_COMPUTE_EXPECT(dst_pyramid.get_pyramid_level(level)->info()->is_resizable(), framework::LogLevel::ERRORS); + } + + ARM_COMPUTE_EXPECT(rec_dst.info()->is_resizable(), framework::LogLevel::ERRORS); +} + +using CLLaplacianReconstructFixture = LaplacianReconstructValidationFixture; + +FIXTURE_DATA_TEST_CASE(RunSmall, CLLaplacianReconstructFixture, framework::DatasetMode::PRECOMMIT, + combine(combine(combine( + datasets::Medium2DShapes(), + datasets::BorderModes()), + small_laplacian_reconstruct_levels), + formats)) +{ + validate_laplacian_reconstruct(_target, _reference, _border_mode, _pyramid_levels); +} + +FIXTURE_DATA_TEST_CASE(RunLarge, CLLaplacianReconstructFixture, framework::DatasetMode::NIGHTLY, + combine(combine(combine( + datasets::Large2DShapes(), + datasets::BorderModes()), + large_laplacian_reconstruct_levels), + formats)) +{ + validate_laplacian_reconstruct(_target, _reference, _border_mode, _pyramid_levels); +} +// clang-format on +// *INDENT-ON* + +TEST_SUITE_END() +TEST_SUITE_END() +} // namespace validation +} // namespace test +} // namespace arm_compute diff --git a/tests/validation/NEON/LaplacianReconstruct.cpp b/tests/validation/NEON/LaplacianReconstruct.cpp new file mode 100644 index 0000000000..b41449ea61 --- /dev/null +++ b/tests/validation/NEON/LaplacianReconstruct.cpp @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2018 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/Types.h" +#include "arm_compute/runtime/NEON/functions/NELaplacianPyramid.h" +#include "arm_compute/runtime/NEON/functions/NELaplacianReconstruct.h" +#include "arm_compute/runtime/Pyramid.h" +#include "arm_compute/runtime/Tensor.h" +#include "arm_compute/runtime/TensorAllocator.h" +#include "tests/NEON/Accessor.h" +#include "tests/datasets/BorderModeDataset.h" +#include "tests/datasets/ShapeDatasets.h" +#include "tests/framework/Asserts.h" +#include "tests/framework/Macros.h" +#include "tests/framework/datasets/Datasets.h" +#include "tests/validation/Validation.h" +#include "tests/validation/fixtures/LaplacianReconstructFixture.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +namespace +{ +const auto small_laplacian_reconstruct_levels = framework::dataset::make("NumLevels", 2, 3); +const auto large_laplacian_reconstruct_levels = framework::dataset::make("NumLevels", 2, 5); + +const auto formats = combine(framework::dataset::make("FormatIn", Format::S16), framework::dataset::make("FormatOut", Format::U8)); + +template +void validate_laplacian_reconstruct(Tensor &target, const SimpleTensor &reference, BorderMode border_mode, size_t num_levels) +{ + const unsigned int filter_size = 5; + const unsigned int border_size(filter_size / 2); + + BorderSize border(std::pow(border_size, num_levels)); + + // Validate output + ValidRegion valid_region = shape_to_valid_region(reference.shape(), border_mode == BorderMode::UNDEFINED, border); + validate(Accessor(target), reference, valid_region); +} +} // namespace + +TEST_SUITE(NEON) +TEST_SUITE(LaplacianReconstruct) + +// *INDENT-OFF* +// clang-format off +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine( + concat(datasets::Medium2DShapes(), datasets::Large2DShapes()), + datasets::BorderModes()), + large_laplacian_reconstruct_levels), + shape, border_mode, num_levels) +{ + // Create pyramid info + PyramidInfo pyramid_info(num_levels, SCALE_PYRAMID_HALF, shape, Format::S16); + Pyramid dst_pyramid{}; + dst_pyramid.init(pyramid_info); + + // Create Tensors + Tensor src = create_tensor(shape, DataType::U8); + + // The first two dimensions of the output tensor must match the first two + // dimensions of the tensor in the last level of the pyramid + TensorShape dst_shape(shape); + dst_shape.set(0, dst_pyramid.get_pyramid_level(num_levels - 1)->info()->dimension(0)); + dst_shape.set(1, dst_pyramid.get_pyramid_level(num_levels - 1)->info()->dimension(1)); + Tensor dst = create_tensor(dst_shape, DataType::S16); + + // The dimensions of the reconstruct are the same as the src shape + Tensor rec_dst = create_tensor(shape, DataType::U8); + + // Create and configure pyramid function + NELaplacianPyramid laplacian_pyramid; + laplacian_pyramid.configure(&src, &dst_pyramid, &dst, border_mode, 0); + + // Create and configure reconstruct function + NELaplacianReconstruct laplacian_reconstruct; + laplacian_reconstruct.configure(&dst_pyramid, &dst, &rec_dst, border_mode, 0); + + ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS); + ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS); + + for(size_t level = 0; level < pyramid_info.num_levels(); ++level) + { + ARM_COMPUTE_EXPECT(dst_pyramid.get_pyramid_level(level)->info()->is_resizable(), framework::LogLevel::ERRORS); + } + + ARM_COMPUTE_EXPECT(rec_dst.info()->is_resizable(), framework::LogLevel::ERRORS); +} + +using NELaplacianReconstructFixture = LaplacianReconstructValidationFixture; + +FIXTURE_DATA_TEST_CASE(RunSmall, NELaplacianReconstructFixture, framework::DatasetMode::PRECOMMIT, + combine(combine(combine( + datasets::Medium2DShapes(), + datasets::BorderModes()), + small_laplacian_reconstruct_levels), + formats)) +{ + validate_laplacian_reconstruct(_target, _reference, _border_mode, _pyramid_levels); +} + +FIXTURE_DATA_TEST_CASE(RunLarge, NELaplacianReconstructFixture, framework::DatasetMode::NIGHTLY, + combine(combine(combine( + datasets::Large2DShapes(), + datasets::BorderModes()), + large_laplacian_reconstruct_levels), + formats)) +{ + validate_laplacian_reconstruct(_target, _reference, _border_mode, _pyramid_levels); +} +// clang-format on +// *INDENT-ON* + +TEST_SUITE_END() +TEST_SUITE_END() +} // namespace validation +} // namespace test +} // namespace arm_compute diff --git a/tests/validation/fixtures/LaplacianReconstructFixture.h b/tests/validation/fixtures/LaplacianReconstructFixture.h new file mode 100644 index 0000000000..dfa302397f --- /dev/null +++ b/tests/validation/fixtures/LaplacianReconstructFixture.h @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2018 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. + */ +#ifndef ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_FIXTURE +#define ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_FIXTURE + +#include "arm_compute/core/IPyramid.h" +#include "arm_compute/core/PyramidInfo.h" +#include "arm_compute/core/TensorShape.h" +#include "arm_compute/core/Types.h" +#include "tests/AssetsLibrary.h" +#include "tests/Globals.h" +#include "tests/IAccessor.h" +#include "tests/framework/Asserts.h" +#include "tests/framework/Fixture.h" +#include "tests/validation/fixtures/LaplacianPyramidFixture.h" +#include "tests/validation/reference/LaplacianPyramid.h" +#include "tests/validation/reference/LaplacianReconstruct.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +template +class LaplacianReconstructValidationFixture : public LaplacianPyramidValidationFixture +{ +public: + template + void setup(TensorShape input_shape, BorderMode border_mode, size_t num_levels, Format format_in, Format format_out) + { + std::mt19937 generator(library->seed()); + std::uniform_int_distribution distribution_u8(0, 255); + const U constant_border_value = distribution_u8(generator); + + using LPF = LaplacianPyramidValidationFixture; + LPF::setup(input_shape, border_mode, num_levels, format_out, format_in); + + // Compute target and reference values using the pyramid and lowest + // resolution tensor output from Laplacian Pyramid kernel + _target = compute_target(input_shape, LPF::_target, LPF::_dst_target, border_mode, constant_border_value); + _reference = compute_reference(LPF::_reference, LPF::_dst_reference, border_mode, constant_border_value); + } + +protected: + template + void fill(V &&tensor) + { + library->fill_tensor_uniform(tensor, 0); + } + + TensorType compute_target(const TensorShape &input_shape, PyramidType &pyramid, TensorType &low_res, BorderMode border_mode, U constant_border_value) + { + // Create tensors + TensorType dst = create_tensor(input_shape, DataType::U8); + + // Create and configure function + FunctionType laplacian_reconstruct; + laplacian_reconstruct.configure(&pyramid, &low_res, &dst, border_mode, constant_border_value); + + // Allocate tensors + dst.allocator()->allocate(); + ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS); + + // Compute function + laplacian_reconstruct.run(); + + return dst; + } + + SimpleTensor compute_reference(const std::vector> &pyramid, + const SimpleTensor &low_res, BorderMode border_mode, U constant_border_value) + { + return reference::laplacian_reconstruct(pyramid, low_res, border_mode, constant_border_value); + } + + TensorType _target{}; + SimpleTensor _reference{}; +}; +} // namespace validation +} // namespace test +} // namespace arm_compute +#endif /* ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_FIXTURE */ diff --git a/tests/validation/reference/LaplacianReconstruct.cpp b/tests/validation/reference/LaplacianReconstruct.cpp new file mode 100644 index 0000000000..23468287b0 --- /dev/null +++ b/tests/validation/reference/LaplacianReconstruct.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2018 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 "LaplacianReconstruct.h" + +#include "arm_compute/core/Types.h" +#include "tests/validation/reference/ArithmeticAddition.h" +#include "tests/validation/reference/DepthConvertLayer.h" +#include "tests/validation/reference/Scale.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +namespace reference +{ +template +SimpleTensor laplacian_reconstruct(const std::vector> &pyramid, const SimpleTensor &low_res, BorderMode border_mode, T constant_border_value) +{ + std::vector> tmp_pyramid(pyramid); + + const size_t last_level = pyramid.size() - 1; + const DataType data_type = low_res.data_type(); + + // input + L(n-1) + tmp_pyramid[last_level] = reference::arithmetic_addition(low_res, pyramid[last_level], data_type, ConvertPolicy::SATURATE); + + // Scale levels n-1 to 1, and add levels n-2 to 0 + for(size_t i = last_level; i-- > 0;) + { + const float scale_x = static_cast(tmp_pyramid[i].shape().x()) / tmp_pyramid[i + 1].shape().x(); + const float scale_y = static_cast(tmp_pyramid[i].shape().y()) / tmp_pyramid[i + 1].shape().y(); + + tmp_pyramid[i] = reference::scale(tmp_pyramid[i + 1], scale_x, scale_y, InterpolationPolicy::NEAREST_NEIGHBOR, + border_mode, constant_border_value, SamplingPolicy::CENTER, false); + + tmp_pyramid[i] = reference::arithmetic_addition(tmp_pyramid[i], pyramid[i], data_type, ConvertPolicy::SATURATE); + } + + return reference::depth_convert(tmp_pyramid[0], DataType::U8, ConvertPolicy::SATURATE, 0); +} + +template SimpleTensor laplacian_reconstruct(const std::vector> &pyramid, const SimpleTensor &low_res, BorderMode border_mode, int16_t constant_border_value); +} // namespace reference +} // namespace validation +} // namespace test +} // namespace arm_compute diff --git a/tests/validation/reference/LaplacianReconstruct.h b/tests/validation/reference/LaplacianReconstruct.h new file mode 100644 index 0000000000..76851c6619 --- /dev/null +++ b/tests/validation/reference/LaplacianReconstruct.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2018 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. + */ +#ifndef __ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_H__ +#define __ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_H__ + +#include "tests/SimpleTensor.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +namespace reference +{ +template +SimpleTensor laplacian_reconstruct(const std::vector> &pyramid, const SimpleTensor &low_res, BorderMode border_mode, T constant_border_value); +} // namespace reference +} // namespace validation +} // namespace test +} // namespace arm_compute +#endif /* __ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_H__ */ -- cgit v1.2.1