| /* |
| |
| * Copyright (c) 2012-2017 The Khronos Group Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #if defined OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION |
| |
| #include "test_engine/test.h" |
| |
| #include <stdint.h> |
| #include <VX/vx.h> |
| #include <VX/vxu.h> |
| |
| // #define USE_OPENCV_GENERATED_REFERENCE |
| #ifndef USE_OPENCV_GENERATED_REFERENCE |
| #include <string.h> |
| #endif |
| #define CANNY_ACCEPTANCE_THRESHOLD 0.95 |
| //#define EXECUTE_ASYNC |
| |
| #define CREF_EDGE 2 |
| #define CREF_LINK 1 |
| #define CREF_NONE 0 |
| |
| static int32_t offsets[][2] = |
| { |
| { -1, -1}, { 0, -1}, { 1, -1}, |
| { -1, 0}, { 1, 0}, |
| { -1, 1}, { 0, 1}, { 1, 1} |
| }; |
| |
| #ifndef USE_OPENCV_GENERATED_REFERENCE |
| static uint64_t magnitude(CT_Image img, uint32_t x, uint32_t y, int32_t k, vx_enum type, int32_t* dx_out, int32_t* dy_out) |
| { |
| static int32_t dim1[][7] = { { 1, 2, 1}, { 1, 4, 6, 4, 1}, { 1, 6, 15, 20, 15, 6, 1}}; |
| static int32_t dim2[][7] = { {-1, 0, 1}, {-1, -2, 0, 2, 1}, {-1, -4, -5, 0, 5, 4, 1}}; |
| int32_t dx = 0, dy = 0; |
| int32_t i,j; |
| |
| int32_t* w1 = dim1[k/2-1]; |
| int32_t* w2 = dim2[k/2-1]; |
| |
| x -= k/2; |
| y -= k/2; |
| |
| for (i = 0; i < k; ++i) |
| { |
| int32_t xx = 0, yy = 0; |
| for (j = 0; j < k; ++j) |
| { |
| vx_int32 v = img->data.y[(y + i) * img->stride + (x + j)]; |
| xx += v * w2[j]; |
| yy += v * w1[j]; |
| } |
| |
| dx += xx * w1[i]; |
| dy += yy * w2[i]; |
| } |
| |
| if (dx_out) *dx_out = dx; |
| if (dy_out) *dy_out = dy; |
| |
| if (type == VX_NORM_L2) |
| return dx * (int64_t)dx + dy * (int64_t)dy; |
| else |
| return (dx < 0 ? -dx : dx) + (dy < 0 ? -dy : dy); |
| } |
| |
| static void follow_edge(CT_Image img, uint32_t x, uint32_t y) |
| { |
| uint32_t i; |
| img->data.y[y * img->stride + x] = 255; |
| for (i = 0; i < sizeof(offsets)/sizeof(offsets[0]); ++i) |
| if (img->data.y[(y + offsets[i][0]) * img->stride + x + offsets[i][1]] == CREF_LINK) |
| follow_edge(img, x + offsets[i][1], y + offsets[i][0]); |
| } |
| |
| static void reference_canny(CT_Image src, CT_Image dst, int32_t low_thresh, int32_t high_thresh, uint32_t gsz, vx_enum norm) |
| { |
| uint64_t lo = norm == VX_NORM_L1 ? low_thresh : low_thresh*low_thresh; |
| uint64_t hi = norm == VX_NORM_L1 ? high_thresh : high_thresh*high_thresh; |
| uint32_t i, j; |
| uint32_t bsz = gsz/2 + 1; |
| |
| ASSERT(src && dst); |
| ASSERT(src->width == dst->width); |
| ASSERT(src->height == dst->height); |
| ASSERT(src->format == VX_DF_IMAGE_U8 && (dst->format == VX_DF_IMAGE_U8 || dst->format == VX_DF_IMAGE_U1)); |
| |
| ASSERT(low_thresh <= high_thresh); |
| ASSERT(low_thresh >= 0); |
| ASSERT(gsz == 3 || gsz == 5 || gsz == 7); |
| ASSERT(norm == VX_NORM_L2 || norm == VX_NORM_L1); |
| ASSERT(src->width >= gsz && src->height >= gsz); |
| |
| CT_Image tmp; |
| if (dst->format == VX_DF_IMAGE_U1) |
| tmp = ct_allocate_image(dst->width, dst->height, VX_DF_IMAGE_U8); |
| else |
| tmp = dst; |
| |
| // zero border pixels |
| for (j = 0; j < bsz; ++j) |
| for (i = 0; i < tmp->width; ++i) |
| tmp->data.y[j * tmp->stride + i] = tmp->data.y[(tmp->height - 1 - j) * tmp->stride + i] = 255; |
| for (j = bsz; j < tmp->height - bsz; ++j) |
| for (i = 0; i < bsz; ++i) |
| tmp->data.y[j * tmp->stride + i] = tmp->data.y[j * tmp->stride + tmp->width - 1 - i] = 255; |
| |
| // threshold + nms |
| for (j = bsz; j < tmp->height - bsz; ++j) |
| { |
| for (i = bsz; i < tmp->width - bsz; ++i) |
| { |
| int32_t dx, dy, e = CREF_NONE; |
| uint64_t m1, m2; |
| |
| uint64_t m = magnitude(src, i, j, gsz, norm, &dx, &dy); |
| |
| if (m > lo) |
| { |
| uint64_t l1 = (dx < 0 ? -dx : dx) + (dy < 0 ? -dy : dy); |
| |
| if (l1 * l1 < (uint64_t)(2 * dx * (int64_t)dx)) // |y| < |x| * tan(pi/8) |
| { |
| m1 = magnitude(src, i-1, j, gsz, norm, 0, 0); |
| m2 = magnitude(src, i+1, j, gsz, norm, 0, 0); |
| } |
| else if (l1 * l1 < (uint64_t)(2 * dy * (int64_t)dy)) // |x| < |y| * tan(pi/8) |
| { |
| m1 = magnitude(src, i, j-1, gsz, norm, 0, 0); |
| m2 = magnitude(src, i, j+1, gsz, norm, 0, 0); |
| } |
| else |
| { |
| int32_t s = (dx ^ dy) < 0 ? -1 : 1; |
| m1 = magnitude(src, i-s, j-1, gsz, norm, 0, 0); |
| m2 = magnitude(src, i+s, j+1, gsz, norm, 0, 0) + 1; // (+1) is OpenCV's gotcha |
| } |
| |
| if (m > m1 && m >= m2) |
| e = (m > hi ? CREF_EDGE : CREF_LINK); |
| } |
| |
| tmp->data.y[j * tmp->stride + i] = e; |
| } |
| } |
| |
| // trace edges |
| for (j = bsz; j < tmp->height - bsz; ++j) |
| for (i = bsz; i < tmp->width - bsz; ++i) |
| if(tmp->data.y[j * tmp->stride + i] == CREF_EDGE) |
| follow_edge(tmp, i, j); |
| |
| // clear non-edges |
| for (j = bsz; j < tmp->height - bsz; ++j) |
| for (i = bsz; i < tmp->width - bsz; ++i) |
| if(tmp->data.y[j * tmp->stride + i] < 255) |
| tmp->data.y[j * tmp->stride + i] = 0; |
| |
| if (dst->format == VX_DF_IMAGE_U1) |
| { |
| U8_ct_image_to_U1_ct_image(tmp, dst); |
| } |
| } |
| #endif |
| |
| // computes count(disttransform(src) >= 2, where dst != 0) |
| static uint32_t disttransform2_metric(CT_Image src, CT_Image dst, CT_Image dist, uint32_t* total_edge_pixels) |
| { |
| uint32_t i, j, k, count, total; |
| |
| ASSERT_(return 0, src && dst && dist && total_edge_pixels); |
| ASSERT_(return 0, src->width == dst->width && src->width == dist->width); |
| ASSERT_(return 0, src->height == dst->height && src->height == dist->height); |
| ASSERT_(return 0, dist->format == VX_DF_IMAGE_U8 && |
| (src->format == VX_DF_IMAGE_U8 || src->format == VX_DF_IMAGE_U1) && |
| (dst->format == VX_DF_IMAGE_U8 || dst->format == VX_DF_IMAGE_U1)); |
| |
| // fill borders with 1 (or 0 for edges) |
| for (i = 0; i < dst->width; ++i) |
| { |
| if (src->format == VX_DF_IMAGE_U1) |
| { |
| uint32_t xShftd = i + src->roi.x % 8; |
| dist->data.y[i] = |
| (src->data.y[xShftd / 8] & (1 << (xShftd % 8))) == 0 ? 1 : 0; |
| dist->data.y[(dist->height - 1) * dist->stride + i] = |
| (src->data.y[(dist->height - 1) * ct_stride_bytes(src) + xShftd / 8] & (1 << (xShftd % 8))) == 0 ? 1 : 0; |
| } |
| else |
| { |
| dist->data.y[i] = src->data.y[i] == 0 ? 1 : 0; |
| dist->data.y[(dist->height - 1) * dist->stride + i] = src->data.y[(dist->height - 1) * src->stride + i] == 0 ? 1 : 0; |
| } |
| } |
| for (j = 1; j < dst->height - 1; ++j) |
| { |
| if (src->format == VX_DF_IMAGE_U1) |
| { |
| uint32_t xShftd = src->roi.x % 8; |
| dist->data.y[j * dist->stride] = |
| (src->data.y[j * ct_stride_bytes(src) + xShftd / 8] & (1 << (xShftd % 8))) == 0 ? 1 : 0; |
| dist->data.y[j * dist->stride + dist->width - 1] = |
| (src->data.y[j * ct_stride_bytes(src) + (xShftd + dist->width - 1) / 8] & (1 << ((xShftd + dist->width - 1) % 8))) == 0 ? 1 : 0; |
| } |
| else |
| { |
| dist->data.y[j * dist->stride] = src->data.y[j * src->stride] == 0 ? 1 : 0; |
| dist->data.y[j * dist->stride + dist->width - 1] = src->data.y[j * src->stride + dist->width - 1] == 0 ? 1 : 0; |
| } |
| } |
| |
| // minimalistic variant of disttransform: |
| // 0 ==> disttransform(src) == 0 |
| // 1 ==> 1 <= disttransform(src) < 2 |
| // 255 ==> disttransform(src) >= 2 |
| for (j = 1; j < src->height-1; ++j) |
| { |
| for (i = 1; i < src->width-1; ++i) |
| { |
| uint32_t xShftd = i + src->roi.x % 8; // Shift for U1 images to account for ROI |
| if ( src->format == VX_DF_IMAGE_U1 |
| ? (src->data.y[j * ct_stride_bytes(src) + xShftd / 8] & (1 << (xShftd % 8))) != 0 |
| : src->data.y[j * src->stride + i] != 0 |
| ) |
| dist->data.y[j * dist->stride + i] = 0; |
| else |
| { |
| int has_edge = 0; |
| for (k = 0; k < sizeof(offsets)/sizeof(offsets[0]); ++k) |
| { |
| if ( src->format == VX_DF_IMAGE_U1 |
| ? (src->data.y[(j + offsets[k][1]) * ct_stride_bytes(src) + (xShftd + offsets[k][0]) / 8] & (1 << (xShftd + offsets[k][0]) % 8)) != 0 |
| : src->data.y[(j + offsets[k][1]) * src->stride + i + offsets[k][0]] != 0 |
| ) |
| { |
| has_edge = 1; |
| break; |
| } |
| } |
| |
| dist->data.y[j * dist->stride + i] = (has_edge ? 1 : 255); |
| } |
| } |
| } |
| |
| // count: pixels where disttransform(src) < 2 and dst != 0 |
| total = count = 0; |
| for (j = 0; j < dst->height; ++j) |
| { |
| for (i = 0; i < dst->width; ++i) |
| { |
| uint32_t xShftd = i + dst->roi.x % 8; |
| if ( dst->format == VX_DF_IMAGE_U1 ? (dst->data.y[j * ct_stride_bytes(dst) + xShftd / 8] & (1 << (xShftd % 8))) != 0 |
| : dst->data.y[j * dst->stride + i] != 0 ) |
| { |
| total += 1; |
| count += (dist->data.y[j * dist->stride + i] < 2) ? 1 : 0; |
| } |
| } |
| } |
| |
| *total_edge_pixels = total; |
| |
| return count; |
| } |
| |
| #ifndef USE_OPENCV_GENERATED_REFERENCE |
| // own blur to not depend on OpenVX borders handling |
| static CT_Image gaussian5x5(CT_Image img) |
| { |
| CT_Image res; |
| uint32_t i, j, k, n; |
| uint32_t ww[] = {1, 4, 6, 4, 1}; |
| |
| ASSERT_(return 0, img); |
| ASSERT_(return 0, img->format == VX_DF_IMAGE_U8); |
| |
| res = ct_allocate_image(img->width, img->height, img->format); |
| ASSERT_(return 0, res); |
| |
| for (j = 0; j < img->height; ++j) |
| { |
| for (i = 0; i < img->width; ++i) |
| { |
| uint32_t r = 0; |
| for (k = 0; k < 5; ++k) |
| { |
| uint32_t rr = 0; |
| uint32_t kj = k + j < 2 ? 0 : (k + j - 2 >= img->width ? img->width -1 : k + j - 2); |
| for (n = 0; n < 5; ++n) |
| { |
| uint32_t ni = n + i < 2 ? 0 : (n + i - 2 >= img->width ? img->width -1 : n + i - 2); |
| rr += ww[n] * img->data.y[kj * img->stride + ni]; |
| } |
| |
| r += rr * ww[k]; |
| } |
| res->data.y[j * res->stride + i] = (r + (1<<7)) >> 8; |
| } |
| } |
| |
| return res; |
| } |
| #endif |
| |
| static CT_Image get_source_image(const char* filename) |
| { |
| #ifndef USE_OPENCV_GENERATED_REFERENCE |
| if (strncmp(filename, "blurred_", 8) == 0) |
| return gaussian5x5(ct_read_image(filename + 8, 1)); |
| else |
| #endif |
| return ct_read_image(filename, 1); |
| } |
| |
| /* |
| #define vxuCannyEdgeDetector vxuCannyEdgeDetector_ref |
| vx_status vxuCannyEdgeDetector_ref(vx_context context, vx_image input, vx_threshold hyst, |
| vx_int32 gradient_size, vx_enum norm_type, |
| vx_image output) |
| { |
| CT_Image src, dst; |
| int32_t hi,lo; |
| vx_image tmp; |
| vx_status s = VX_SUCCESS; |
| |
| src = ct_image_from_vx_image(input); |
| dst = ct_allocate_image(src->width, src->height, VX_DF_IMAGE_U8); |
| |
| s |= vxQueryThreshold(hyst, VX_THRESHOLD_THRESHOLD_LOWER, &lo, sizeof(lo)); |
| s |= vxQueryThreshold(hyst, VX_THRESHOLD_THRESHOLD_UPPER, &hi, sizeof(hi)); |
| |
| reference_canny(src, dst, lo, hi, gradient_size, norm_type); |
| tmp = vxCreateImage(context, src->width, src->height, VX_DF_IMAGE_U8); |
| s |= vxuNot(context, ct_image_to_vx_image(dst, context), tmp); |
| s |= vxuNot(context, tmp, output); |
| return s; |
| } |
| */ |
| |
| static CT_Image get_reference_result(const char* src_name, CT_Image src, int32_t low_thresh, int32_t high_thresh, uint32_t gsz, vx_enum norm, vx_df_image out_format) |
| { |
| #ifdef USE_OPENCV_GENERATED_REFERENCE |
| CT_Image tmp_dst, dst; |
| char buff[1024]; |
| sprintf(buff, "canny_%ux%u_%d_%d_%s_%s", gsz, gsz, low_thresh, high_thresh, norm == VX_NORM_L1 ? "L1" : "L2", src_name); |
| // printf("reading: %s\n", buff); |
| |
| tmp_dst = ct_read_image(buff, 1); |
| if ( out_format == VX_DF_IMAGE_U1 && (dst = ct_allocate_image(tmp_dst->width, tmp_dst->height, VX_DF_IMAGE_U1)) ) |
| U8_ct_image_to_U1_ct_image(tmp_dst, dst); |
| else |
| dst = tmp_dst; |
| |
| return dst; |
| #else |
| CT_Image dst; |
| ASSERT_(return 0, src); |
| if ( (dst = ct_allocate_image(src->width, src->height, out_format)) ) |
| reference_canny(src, dst, low_thresh, high_thresh, gsz, norm); |
| return dst; |
| #endif |
| } |
| |
| TESTCASE(vxuCanny, CT_VXContext, ct_setup_vx_context, 0) |
| TESTCASE(vxCanny, CT_VXContext, ct_setup_vx_context, 0) |
| |
| typedef struct { |
| const char* name; |
| const char* filename; |
| int32_t grad_size; |
| vx_enum norm_type; |
| int32_t low_thresh; |
| int32_t high_thresh; |
| vx_df_image out_format; |
| } canny_arg; |
| |
| #define BIT_EXACT_ARG_U8(grad, thresh) ARG(#grad "x" #grad " thresh=" #thresh " output=VX_DF_IMAGE_U8", "lena_gray.bmp", grad, VX_NORM_L1, thresh, thresh, VX_DF_IMAGE_U8) |
| #define BIT_EXACT_ARG_U1(grad, thresh) ARG("_U1_/" #grad "x" #grad " thresh=" #thresh " output=VX_DF_IMAGE_U1", "lena_gray.bmp", grad, VX_NORM_L1, thresh, thresh, VX_DF_IMAGE_U1) |
| |
| TEST_WITH_ARG(vxuCanny, BitExactL1, canny_arg, |
| BIT_EXACT_ARG_U8(3, 120), |
| BIT_EXACT_ARG_U8(5, 100), |
| BIT_EXACT_ARG_U1(3, 120), |
| BIT_EXACT_ARG_U1(5, 100) |
| ) |
| { |
| vx_image src, dst; |
| vx_threshold hyst; |
| CT_Image lena, vxdst, refdst; |
| vx_int32 low_thresh = arg_->low_thresh; |
| vx_int32 high_thresh = arg_->high_thresh; |
| vx_border_t border = { VX_BORDER_UNDEFINED, {{ 0 }} }; |
| vx_int32 border_width = arg_->grad_size/2 + 1; |
| vx_df_image output_format = arg_->out_format; |
| vx_context context = context_->vx_context_; |
| vx_df_image input_format = VX_DF_IMAGE_U8; |
| vx_pixel_value_t low_pixel; |
| vx_pixel_value_t high_pixel; |
| memset(&low_pixel, 0, sizeof(low_pixel)); |
| memset(&high_pixel, 0, sizeof(high_pixel)); |
| low_pixel.U8 = low_thresh; |
| high_pixel.U8 = high_thresh; |
| |
| ASSERT((output_format == VX_DF_IMAGE_U8) || (output_format == VX_DF_IMAGE_U1)); |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetContextAttribute(context, VX_CONTEXT_IMMEDIATE_BORDER, &border, sizeof(border))); |
| |
| ASSERT_NO_FAILURE(lena = get_source_image(arg_->filename)); |
| ASSERT_NO_FAILURE(src = ct_image_to_vx_image(lena, context)); |
| ASSERT_VX_OBJECT(dst = vxCreateImage(context, lena->width, lena->height, output_format), VX_TYPE_IMAGE); |
| |
| ASSERT_VX_OBJECT(hyst = vxCreateThresholdForImage(context, VX_THRESHOLD_TYPE_RANGE, input_format, output_format), VX_TYPE_THRESHOLD); |
| VX_CALL(vxCopyThresholdRange(hyst, &low_pixel, &high_pixel, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); |
| /* explicitly set FALSE_VALUE and TRUE_VALUE for hyst parameter */ |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxuCannyEdgeDetector(context, src, hyst, arg_->grad_size, arg_->norm_type, dst)); |
| |
| ASSERT_NO_FAILURE(vxdst = ct_image_from_vx_image(dst)); |
| ASSERT_NO_FAILURE(refdst = get_reference_result(arg_->filename, lena, low_thresh, high_thresh, arg_->grad_size, |
| arg_->norm_type, output_format)); |
| |
| ASSERT_NO_FAILURE(ct_adjust_roi(vxdst, border_width, border_width, border_width, border_width)); |
| ASSERT_NO_FAILURE(ct_adjust_roi(refdst, border_width, border_width, border_width, border_width)); |
| |
| #if 0 |
| printf("=== SRC ===\n"); |
| ct_dump_image_info(lena); |
| printf("=== VX ===\n"); |
| ct_dump_image_info(vxdst); |
| printf("=== REF ===\n"); |
| ct_dump_image_info(refdst); |
| ct_write_image("canny_src.bmp", lena); |
| ct_write_image("canny_res_vx.bmp", vxdst); |
| ct_write_image("canny_res_ref.bmp", refdst); |
| #endif |
| |
| ASSERT_EQ_CTIMAGE(refdst, vxdst); |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseThreshold(&hyst)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&src)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&dst)); |
| } |
| |
| TEST_WITH_ARG(vxCanny, BitExactL1, canny_arg, |
| BIT_EXACT_ARG_U8(3, 120), |
| BIT_EXACT_ARG_U8(5, 100), |
| BIT_EXACT_ARG_U1(3, 120), |
| BIT_EXACT_ARG_U1(5, 100) |
| ) |
| { |
| vx_image src, dst; |
| vx_graph graph; |
| vx_node node; |
| vx_threshold hyst; |
| CT_Image lena, vxdst, refdst; |
| vx_int32 low_thresh = arg_->low_thresh; |
| vx_int32 high_thresh = arg_->high_thresh; |
| vx_border_t border = { VX_BORDER_UNDEFINED, {{ 0 }} }; |
| vx_int32 border_width = arg_->grad_size/2 + 1; |
| vx_df_image output_format = arg_->out_format; |
| vx_context context = context_->vx_context_; |
| vx_df_image input_format = VX_DF_IMAGE_U8; |
| vx_pixel_value_t low_pixel; |
| vx_pixel_value_t high_pixel; |
| memset(&low_pixel, 0, sizeof(low_pixel)); |
| memset(&high_pixel, 0, sizeof(high_pixel)); |
| low_pixel.U8 = low_thresh; |
| high_pixel.U8 = high_thresh; |
| |
| ASSERT((output_format == VX_DF_IMAGE_U8) || (output_format == VX_DF_IMAGE_U1)); |
| |
| ASSERT_NO_FAILURE(lena = get_source_image(arg_->filename)); |
| ASSERT_NO_FAILURE(src = ct_image_to_vx_image(lena, context)); |
| ASSERT_VX_OBJECT(dst = vxCreateImage(context, lena->width, lena->height, output_format), VX_TYPE_IMAGE); |
| |
| ASSERT_VX_OBJECT(hyst = vxCreateThresholdForImage(context, VX_THRESHOLD_TYPE_RANGE, input_format, output_format), VX_TYPE_THRESHOLD); |
| VX_CALL(vxCopyThresholdRange(hyst, &low_pixel, &high_pixel, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); |
| /* explicitly set FALSE_VALUE and TRUE_VALUE for hyst parameter */ |
| |
| ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH); |
| ASSERT_VX_OBJECT(node = vxCannyEdgeDetectorNode(graph, src, hyst, arg_->grad_size, arg_->norm_type, dst), VX_TYPE_NODE); |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetNodeAttribute(node, VX_NODE_BORDER, &border, sizeof(border))); |
| |
| // run graph |
| #ifdef EXECUTE_ASYNC |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxScheduleGraph(graph)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxWaitGraph(graph)); |
| #else |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxProcessGraph(graph)); |
| #endif |
| |
| ASSERT_NO_FAILURE(vxdst = ct_image_from_vx_image(dst)); |
| ASSERT_NO_FAILURE(refdst = get_reference_result(arg_->filename, lena, low_thresh, high_thresh, arg_->grad_size, |
| arg_->norm_type, output_format)); |
| |
| ASSERT_NO_FAILURE(ct_adjust_roi(vxdst, border_width, border_width, border_width, border_width)); |
| ASSERT_NO_FAILURE(ct_adjust_roi(refdst, border_width, border_width, border_width, border_width)); |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseNode(&node)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseGraph(&graph)); |
| |
| #if 0 |
| printf("=== SRC ===\n"); |
| ct_dump_image_info(lena); |
| printf("=== VX ===\n"); |
| ct_dump_image_info(vxdst); |
| printf("=== REF ===\n"); |
| ct_dump_image_info(refdst); |
| ct_write_image("canny_src.bmp", lena); |
| ct_write_image("canny_res_vx.bmp", vxdst); |
| ct_write_image("canny_res_ref.bmp", refdst); |
| #endif |
| |
| ASSERT_EQ_CTIMAGE(refdst, vxdst); |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseThreshold(&hyst)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&src)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&dst)); |
| } |
| |
| #define CANNY_ARG_U8(grad, norm, lo, hi, file) ARG(#file "/" #norm " " #grad "x" #grad " thresh=(" #lo ", " #hi ") output=VX_DF_IMAGE_U8", #file ".bmp", grad, VX_NORM_##norm, lo, hi, VX_DF_IMAGE_U8) |
| #define CANNY_ARG_U1(grad, norm, lo, hi, file) ARG("_U1_/" #file "/" #norm " " #grad "x" #grad " thresh=(" #lo ", " #hi ") output=VX_DF_IMAGE_U1", #file ".bmp", grad, VX_NORM_##norm, lo, hi, VX_DF_IMAGE_U1) |
| |
| TEST_WITH_ARG(vxuCanny, Lena, canny_arg, |
| CANNY_ARG_U8(3, L1, 100, 120, lena_gray), |
| CANNY_ARG_U8(3, L2, 100, 120, lena_gray), |
| CANNY_ARG_U8(3, L1, 90, 130, lena_gray), |
| CANNY_ARG_U8(3, L2, 90, 130, lena_gray), |
| CANNY_ARG_U8(3, L1, 70, 71 , lena_gray), |
| CANNY_ARG_U8(3, L2, 70, 71 , lena_gray), |
| CANNY_ARG_U8(3, L1, 150, 220, lena_gray), |
| CANNY_ARG_U8(3, L2, 150, 220, lena_gray), |
| CANNY_ARG_U8(5, L1, 100, 120, lena_gray), |
| CANNY_ARG_U8(5, L2, 100, 120, lena_gray), |
| CANNY_ARG_U8(7, L1, 100, 120, lena_gray), |
| CANNY_ARG_U8(7, L2, 100, 120, lena_gray), |
| |
| CANNY_ARG_U8(5, L1, 1200, 1440, lena_gray), |
| CANNY_ARG_U8(5, L2, 1200, 1440, lena_gray), |
| CANNY_ARG_U8(7, L1, 16000, 19200, lena_gray), |
| CANNY_ARG_U8(7, L2, 16000, 19200, lena_gray), |
| |
| CANNY_ARG_U8(3, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(3, L1, 90, 125, blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 90, 130, blurred_lena_gray), |
| CANNY_ARG_U8(3, L1, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U8(3, L1, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U8(5, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(5, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(7, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(7, L2, 100, 120, blurred_lena_gray), |
| |
| CANNY_ARG_U1(3, L1, 100, 120, lena_gray), |
| CANNY_ARG_U1(3, L2, 100, 120, lena_gray), |
| CANNY_ARG_U1(3, L1, 90, 130, lena_gray), |
| CANNY_ARG_U1(3, L2, 90, 130, lena_gray), |
| CANNY_ARG_U1(3, L1, 70, 71 , lena_gray), |
| CANNY_ARG_U1(3, L2, 70, 71 , lena_gray), |
| CANNY_ARG_U1(3, L1, 150, 220, lena_gray), |
| CANNY_ARG_U1(3, L2, 150, 220, lena_gray), |
| CANNY_ARG_U1(5, L1, 100, 120, lena_gray), |
| CANNY_ARG_U1(5, L2, 100, 120, lena_gray), |
| CANNY_ARG_U1(7, L1, 100, 120, lena_gray), |
| CANNY_ARG_U1(7, L2, 100, 120, lena_gray), |
| |
| CANNY_ARG_U1(5, L1, 1200, 1440, lena_gray), |
| CANNY_ARG_U1(5, L2, 1200, 1440, lena_gray), |
| CANNY_ARG_U1(7, L1, 16000, 19200, lena_gray), |
| CANNY_ARG_U1(7, L2, 16000, 19200, lena_gray), |
| |
| CANNY_ARG_U1(3, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(3, L1, 90, 125, blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 90, 130, blurred_lena_gray), |
| CANNY_ARG_U1(3, L1, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U1(3, L1, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U1(5, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(5, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(7, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(7, L2, 100, 120, blurred_lena_gray), |
| ) |
| { |
| uint32_t total, count; |
| vx_image src, dst; |
| vx_threshold hyst; |
| CT_Image lena, vxdst, refdst, dist; |
| vx_int32 low_thresh = arg_->low_thresh; |
| vx_int32 high_thresh = arg_->high_thresh; |
| vx_border_t border = { VX_BORDER_UNDEFINED, {{ 0 }} }; |
| vx_int32 border_width = arg_->grad_size/2 + 1; |
| vx_df_image output_format = arg_->out_format; |
| vx_context context = context_->vx_context_; |
| vx_df_image input_format = VX_DF_IMAGE_U8; |
| vx_pixel_value_t low_pixel; |
| vx_pixel_value_t high_pixel; |
| memset(&low_pixel, 0, sizeof(low_pixel)); |
| memset(&high_pixel, 0, sizeof(high_pixel)); |
| low_pixel.U8 = low_thresh; |
| high_pixel.U8 = high_thresh; |
| if (low_thresh > 255) |
| { |
| input_format = VX_DF_IMAGE_S16; |
| low_pixel.S16 = low_thresh; |
| high_pixel.S16 = high_thresh; |
| } |
| |
| ASSERT((output_format == VX_DF_IMAGE_U8) || (output_format == VX_DF_IMAGE_U1)); |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetContextAttribute(context, VX_CONTEXT_IMMEDIATE_BORDER, &border, sizeof(border))); |
| |
| ASSERT_NO_FAILURE(lena = get_source_image(arg_->filename)); |
| ASSERT_NO_FAILURE(src = ct_image_to_vx_image(lena, context)); |
| ASSERT_VX_OBJECT(dst = vxCreateImage(context, lena->width, lena->height, output_format), VX_TYPE_IMAGE); |
| |
| ASSERT_VX_OBJECT(hyst = vxCreateThresholdForImage(context, VX_THRESHOLD_TYPE_RANGE, input_format, output_format), VX_TYPE_THRESHOLD); |
| VX_CALL(vxCopyThresholdRange(hyst, &low_pixel, &high_pixel, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); |
| /* FALSE_VALUE and TRUE_VALUE of hyst parameter are set to their default values (0, 255) by vxCreateThreshold */ |
| /* test reference data are computed with assumption that FALSE_VALUE and TRUE_VALUE set to 0 and 255 */ |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxuCannyEdgeDetector(context, src, hyst, arg_->grad_size, arg_->norm_type, dst)); |
| |
| ASSERT_NO_FAILURE(vxdst = ct_image_from_vx_image(dst)); |
| ASSERT_NO_FAILURE(refdst = get_reference_result(arg_->filename, lena, low_thresh, high_thresh, arg_->grad_size, |
| arg_->norm_type, output_format)); |
| |
| ASSERT_NO_FAILURE(ct_adjust_roi(vxdst, border_width, border_width, border_width, border_width)); |
| ASSERT_NO_FAILURE(ct_adjust_roi(refdst, border_width, border_width, border_width, border_width)); |
| |
| ASSERT_NO_FAILURE(dist = ct_allocate_image(refdst->width, refdst->height, VX_DF_IMAGE_U8)); |
| |
| // disttransform(x,y) < tolerance for all (x,y) such that output(x,y) = 255, |
| // where disttransform is the distance transform image with Euclidean distance |
| // of the reference(x,y) (canny edge ground truth). This condition should be |
| // satisfied by 95% of output edge pixels, tolerance = 2. |
| ASSERT_NO_FAILURE(count = disttransform2_metric(refdst, vxdst, dist, &total)); |
| |
| if (count < CANNY_ACCEPTANCE_THRESHOLD * total) |
| { |
| CT_RecordFailureAtFormat("disttransform(reference) < 2 only for %u of %u pixels of output edges which is %.2f%% < %.2f%%", __FUNCTION__, __FILE__, __LINE__, |
| count, total, count/(double)total*100, CANNY_ACCEPTANCE_THRESHOLD*100); |
| |
| // ct_write_image("canny_vx.bmp", vxdst); |
| // ct_write_image("canny_ref.bmp", refdst); |
| } |
| |
| // And the inverse: disttransform(x,y) < tolerance for all (x,y) such that |
| // reference(x,y) = 255, where disttransform is the distance transform image |
| // with Euclidean distance of the output(x,y) (canny edge ground truth). This |
| // condition should be satisfied by 95% of reference edge pixels, tolerance = 2. |
| ASSERT_NO_FAILURE(count = disttransform2_metric(vxdst, refdst, dist, &total)); |
| |
| if (count < CANNY_ACCEPTANCE_THRESHOLD * total) |
| { |
| CT_RecordFailureAtFormat("disttransform(output) < 2 only for %u of %u pixels of reference edges which is %.2f%% < %.2f%%", __FUNCTION__, __FILE__, __LINE__, |
| count, total, count/(double)total*100, CANNY_ACCEPTANCE_THRESHOLD*100); |
| |
| // ct_write_image("canny_vx.bmp", vxdst); |
| // ct_write_image("canny_ref.bmp", refdst); |
| } |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseThreshold(&hyst)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&src)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&dst)); |
| } |
| |
| TEST_WITH_ARG(vxCanny, Lena, canny_arg, |
| CANNY_ARG_U8(3, L1, 100, 120, lena_gray), |
| CANNY_ARG_U8(3, L2, 100, 120, lena_gray), |
| CANNY_ARG_U8(3, L1, 90, 130, lena_gray), |
| CANNY_ARG_U8(3, L2, 90, 130, lena_gray), |
| CANNY_ARG_U8(3, L1, 70, 71 , lena_gray), |
| CANNY_ARG_U8(3, L2, 70, 71 , lena_gray), |
| CANNY_ARG_U8(3, L1, 150, 220, lena_gray), |
| CANNY_ARG_U8(3, L2, 150, 220, lena_gray), |
| CANNY_ARG_U8(5, L1, 100, 120, lena_gray), |
| CANNY_ARG_U8(5, L2, 100, 120, lena_gray), |
| CANNY_ARG_U8(7, L1, 100, 120, lena_gray), |
| CANNY_ARG_U8(7, L2, 100, 120, lena_gray), |
| |
| CANNY_ARG_U8(5, L1, 1200, 1440, lena_gray), |
| CANNY_ARG_U8(5, L2, 1200, 1440, lena_gray), |
| CANNY_ARG_U8(7, L1, 16000, 19200, lena_gray), |
| CANNY_ARG_U8(7, L2, 16000, 19200, lena_gray), |
| |
| CANNY_ARG_U8(3, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(3, L1, 90, 125, blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 90, 130, blurred_lena_gray), |
| CANNY_ARG_U8(3, L1, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U8(3, L1, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U8(3, L2, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U8(5, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(5, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(7, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U8(7, L2, 100, 120, blurred_lena_gray), |
| |
| CANNY_ARG_U1(3, L1, 100, 120, lena_gray), |
| CANNY_ARG_U1(3, L2, 100, 120, lena_gray), |
| CANNY_ARG_U1(3, L1, 90, 130, lena_gray), |
| CANNY_ARG_U1(3, L2, 90, 130, lena_gray), |
| CANNY_ARG_U1(3, L1, 70, 71 , lena_gray), |
| CANNY_ARG_U1(3, L2, 70, 71 , lena_gray), |
| CANNY_ARG_U1(3, L1, 150, 220, lena_gray), |
| CANNY_ARG_U1(3, L2, 150, 220, lena_gray), |
| CANNY_ARG_U1(5, L1, 100, 120, lena_gray), |
| CANNY_ARG_U1(5, L2, 100, 120, lena_gray), |
| CANNY_ARG_U1(7, L1, 100, 120, lena_gray), |
| CANNY_ARG_U1(7, L2, 100, 120, lena_gray), |
| |
| CANNY_ARG_U1(5, L1, 1200, 1440, lena_gray), |
| CANNY_ARG_U1(5, L2, 1200, 1440, lena_gray), |
| CANNY_ARG_U1(7, L1, 16000, 19200, lena_gray), |
| CANNY_ARG_U1(7, L2, 16000, 19200, lena_gray), |
| |
| CANNY_ARG_U1(3, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(3, L1, 90, 125, blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 90, 130, blurred_lena_gray), |
| CANNY_ARG_U1(3, L1, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 70, 71 , blurred_lena_gray), |
| CANNY_ARG_U1(3, L1, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U1(3, L2, 150, 220, blurred_lena_gray), |
| CANNY_ARG_U1(5, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(5, L2, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(7, L1, 100, 120, blurred_lena_gray), |
| CANNY_ARG_U1(7, L2, 100, 120, blurred_lena_gray), |
| |
| ) |
| { |
| uint32_t total, count; |
| vx_image src, dst; |
| vx_threshold hyst; |
| vx_graph graph; |
| vx_node node; |
| CT_Image lena, vxdst, refdst, dist; |
| vx_int32 low_thresh = arg_->low_thresh; |
| vx_int32 high_thresh = arg_->high_thresh; |
| vx_border_t border = { VX_BORDER_UNDEFINED, {{ 0 }} }; |
| vx_int32 border_width = arg_->grad_size/2 + 1; |
| vx_df_image output_format = arg_->out_format; |
| vx_context context = context_->vx_context_; |
| vx_df_image input_format = VX_DF_IMAGE_U8; |
| vx_pixel_value_t low_pixel; |
| vx_pixel_value_t high_pixel; |
| memset(&low_pixel, 0, sizeof(low_pixel)); |
| memset(&high_pixel, 0, sizeof(high_pixel)); |
| low_pixel.U8 = low_thresh; |
| high_pixel.U8 = high_thresh; |
| if (low_thresh > 255) |
| { |
| input_format = VX_DF_IMAGE_S16; |
| low_pixel.S16 = low_thresh; |
| high_pixel.S16 = high_thresh; |
| } |
| |
| ASSERT((output_format == VX_DF_IMAGE_U8) || (output_format == VX_DF_IMAGE_U1)); |
| |
| ASSERT_NO_FAILURE(lena = get_source_image(arg_->filename)); |
| ASSERT_NO_FAILURE(src = ct_image_to_vx_image(lena, context)); |
| ASSERT_VX_OBJECT(dst = vxCreateImage(context, lena->width, lena->height, output_format), VX_TYPE_IMAGE); |
| |
| ASSERT_VX_OBJECT(hyst = vxCreateThresholdForImage(context, VX_THRESHOLD_TYPE_RANGE, input_format, output_format), VX_TYPE_THRESHOLD); |
| VX_CALL(vxCopyThresholdRange(hyst, &low_pixel, &high_pixel, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); |
| /* FALSE_VALUE and TRUE_VALUE of hyst parameter are set to their default values (0, 255) by vxCreateThreshold */ |
| /* test reference data are computed with assumption that FALSE_VALUE and TRUE_VALUE set to 0 and 255 */ |
| |
| ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH); |
| ASSERT_VX_OBJECT(node = vxCannyEdgeDetectorNode(graph, src, hyst, arg_->grad_size, arg_->norm_type, dst), VX_TYPE_NODE); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetNodeAttribute(node, VX_NODE_BORDER, &border, sizeof(border))); |
| |
| // run graph |
| #ifdef EXECUTE_ASYNC |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxScheduleGraph(graph)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxWaitGraph(graph)); |
| #else |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxProcessGraph(graph)); |
| #endif |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseNode(&node)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseGraph(&graph)); |
| |
| ASSERT_NO_FAILURE(vxdst = ct_image_from_vx_image(dst)); |
| ASSERT_NO_FAILURE(refdst = get_reference_result(arg_->filename, lena, low_thresh, high_thresh, arg_->grad_size, |
| arg_->norm_type, output_format)); |
| |
| ASSERT_NO_FAILURE(ct_adjust_roi(vxdst, border_width, border_width, border_width, border_width)); |
| ASSERT_NO_FAILURE(ct_adjust_roi(refdst, border_width, border_width, border_width, border_width)); |
| |
| ASSERT_NO_FAILURE(dist = ct_allocate_image(refdst->width, refdst->height, VX_DF_IMAGE_U8)); |
| |
| // disttransform(x,y) < tolerance for all (x,y) such that output(x,y) = 255, |
| // where disttransform is the distance transform image with Euclidean distance |
| // of the reference(x,y) (canny edge ground truth). This condition should be |
| // satisfied by 95% of output edge pixels, tolerance = 2. |
| ASSERT_NO_FAILURE(count = disttransform2_metric(refdst, vxdst, dist, &total)); |
| |
| if (count < CANNY_ACCEPTANCE_THRESHOLD * total) |
| { |
| CT_RecordFailureAtFormat("disttransform(reference) < 2 only for %u of %u pixels of output edges which is %.2f%% < %.2f%%", __FUNCTION__, __FILE__, __LINE__, |
| count, total, count/(double)total*100, CANNY_ACCEPTANCE_THRESHOLD*100); |
| |
| // ct_write_image("canny_vx.bmp", vxdst); |
| // ct_write_image("canny_ref.bmp", refdst); |
| } |
| |
| // And the inverse: disttransform(x,y) < tolerance for all (x,y) such that |
| // reference(x,y) = 255, where disttransform is the distance transform image |
| // with Euclidean distance of the output(x,y) (canny edge ground truth). This |
| // condition should be satisfied by 95% of reference edge pixels, tolerance = 2. |
| ASSERT_NO_FAILURE(count = disttransform2_metric(vxdst, refdst, dist, &total)); |
| if (count < CANNY_ACCEPTANCE_THRESHOLD * total) |
| { |
| CT_RecordFailureAtFormat("disttransform(output) < 2 only for %u of %u pixels of reference edges which is %.2f%% < %.2f%%", __FUNCTION__, __FILE__, __LINE__, |
| count, total, count/(double)total*100, CANNY_ACCEPTANCE_THRESHOLD*100); |
| |
| // ct_write_image("canny_vx.bmp", vxdst); |
| // ct_write_image("canny_ref.bmp", refdst); |
| } |
| |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseThreshold(&hyst)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&src)); |
| ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxReleaseImage(&dst)); |
| } |
| |
| TESTCASE_TESTS(vxuCanny, DISABLED_BitExactL1, Lena) |
| TESTCASE_TESTS(vxCanny, DISABLED_BitExactL1, Lena) |
| |
| #endif //OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION |
