Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Optimization ximgproc::thinning #3801

Open
wants to merge 1 commit into
base: 4.x
Choose a base branch
from
Open

Optimization ximgproc::thinning #3801

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
61 changes: 18 additions & 43 deletions modules/ximgproc/include/opencv2/ximgproc.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,38 +1,6 @@
/*
* By downloading, copying, installing or using the software you agree to this license.
* If you do not agree to this license, do not download, install,
* copy or use the software.
*
*
* License Agreement
* For Open Source Computer Vision Library
* (3 - clause BSD License)
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met :
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and / or other materials provided with the distribution.
*
* * Neither the names of the copyright holders nor the names of the contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided by the copyright holders and contributors "as is" and
* any express or implied warranties, including, but not limited to, the implied
* warranties of merchantability and fitness for a particular purpose are disclaimed.
* In no event shall copyright holders or contributors be liable for any direct,
* indirect, incidental, special, exemplary, or consequential damages
* (including, but not limited to, procurement of substitute goods or services;
* loss of use, data, or profits; or business interruption) however caused
* and on any theory of liability, whether in contract, strict liability,
* or tort(including negligence or otherwise) arising in any way out of
* the use of this software, even if advised of the possibility of such damage.
*/
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.

#ifndef __OPENCV_XIMGPROC_HPP__
#define __OPENCV_XIMGPROC_HPP__
Expand Down Expand Up @@ -68,6 +36,8 @@
/**
@defgroup ximgproc Extended Image Processing
@{
@defgroup ximgproc_binarization Binarization
@defgroup ximgproc_edge Structured forests for fast edge detection
This module contains implementations of modern structured edge detection algorithms,
Expand Down Expand Up @@ -124,7 +94,7 @@ namespace cv
namespace ximgproc
{

//! @addtogroup ximgproc
//! @addtogroup ximgproc_binarization
//! @{

enum ThinningTypes{
Expand Down Expand Up @@ -179,15 +149,20 @@ CV_EXPORTS_W void niBlackThreshold( InputArray _src, OutputArray _dst,
int blockSize, double k, int binarizationMethod = BINARIZATION_NIBLACK,
double r = 128 );

/** @brief Applies a binary blob thinning operation, to achieve a skeletization of the input image.
/** @brief Performs binary image thinning to obtain a skeletonized representation of the input image.
The function transforms a binary blob image into a skeletized form using the technique of Zhang-Suen.
This function applies a thinning algorithm, reducing the binary blobs in the input image to a skeletal form.
By default, it uses the Zhang-Suen technique, which iteratively removes pixels from the boundaries of the blobs
while preserving the overall structure and connectivity of the objects.
@param src Source image: an 8-bit, single-channel binary image where the blobs are represented by pixels with a value of 255 (white),
and the background is 0 (black).
@param dst Destination image of the same size and type as src, where the result of the thinning operation will be stored.
This operation can be performed in-place, meaning `src` and `dst` can be the same.
@param thinningType The thinning algorithm to apply. By default, the Zhang-Suen algorithm is used. See cv::ximgproc::ThinningTypes for other options.
*/
CV_EXPORTS_W void thinning(InputArray src, OutputArray dst, int thinningType = THINNING_ZHANGSUEN);

@param src Source 8-bit single-channel image, containing binary blobs, with blobs having 255 pixel values.
@param dst Destination image of the same size and the same type as src. The function can work in-place.
@param thinningType Value that defines which thinning algorithm should be used. See cv::ximgproc::ThinningTypes
*/
CV_EXPORTS_W void thinning( InputArray src, OutputArray dst, int thinningType = THINNING_ZHANGSUEN);

/** @brief Performs anisotropic diffusion on an image.
Expand Down
151 changes: 52 additions & 99 deletions modules/ximgproc/src/thinning.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -92,118 +92,71 @@ static uint8_t lut_guo_iter1[] = {
1, 1, 1, 1};

// Applies a thinning iteration to a binary image
static void thinningIteration(Mat img, int iter, int thinningType){
Mat marker = Mat::zeros(img.size(), CV_8UC1);
static void thinningIteration(Mat &img, Mat &marker, const uint8_t* const lut, bool &changed) {
int rows = img.rows;
int cols = img.cols;
marker.col(0).setTo(1);
marker.col(cols - 1).setTo(1);
marker.row(0).setTo(1);
marker.row(rows - 1).setTo(1);

if(thinningType == THINNING_ZHANGSUEN){
marker.forEach<uchar>([=](uchar& value, const int postion[]) {
int i = postion[0];
int j = postion[1];
if (i == 0 || j == 0 || i == rows - 1 || j == cols - 1)
return;

auto ptr = img.ptr(i, j); // p1

// p9 p2 p3
// p8 p1 p4
// p7 p6 p5
uchar p2 = ptr[-cols];
uchar p3 = ptr[-cols + 1];
uchar p4 = ptr[1];
uchar p5 = ptr[cols + 1];
uchar p6 = ptr[cols];
uchar p7 = ptr[cols - 1];
uchar p8 = ptr[-1];
uchar p9 = ptr[-cols - 1];

int neighbors = p9 | (p2 << 1) | (p3 << 2) | (p4 << 3) | (p5 << 4) | (p6 << 5) | (p7 << 6) | (p8 << 7);

if (iter == 0)
value = lut_zhang_iter0[neighbors];
else
value = lut_zhang_iter1[neighbors];

//int A = (p2 == 0 && p3 == 1) + (p3 == 0 && p4 == 1) +
// (p4 == 0 && p5 == 1) + (p5 == 0 && p6 == 1) +
// (p6 == 0 && p7 == 1) + (p7 == 0 && p8 == 1) +
// (p8 == 0 && p9 == 1) + (p9 == 0 && p2 == 1);
//int B = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9;
//int m1 = iter == 0 ? (p2 * p4 * p6) : (p2 * p4 * p8);
//int m2 = iter == 0 ? (p4 * p6 * p8) : (p2 * p6 * p8);
//if (A == 1 && (B >= 2 && B <= 6) && m1 == 0 && m2 == 0) value = 0;
// else value = 1;
});
}
if(thinningType == THINNING_GUOHALL){
marker.forEach<uchar>([=](uchar& value, const int postion[]) {
int i = postion[0];
int j = postion[1];
if (i == 0 || j == 0 || i == rows - 1 || j == cols - 1)
return;

auto ptr = img.ptr(i, j); // p1

// p9 p2 p3
// p8 p1 p4
// p7 p6 p5
uchar p2 = ptr[-cols];
uchar p3 = ptr[-cols + 1];
uchar p4 = ptr[1];
uchar p5 = ptr[cols + 1];
uchar p6 = ptr[cols];
uchar p7 = ptr[cols - 1];
uchar p8 = ptr[-1];
uchar p9 = ptr[-cols - 1];

int neighbors = p9 | (p2 << 1) | (p3 << 2) | (p4 << 3) | (p5 << 4) | (p6 << 5) | (p7 << 6) | (p8 << 7);

if (iter == 0)
value = lut_guo_iter0[neighbors];
else
value = lut_guo_iter1[neighbors];

//int C = ((!p2) & (p3 | p4)) + ((!p4) & (p5 | p6)) +
// ((!p6) & (p7 | p8)) + ((!p8) & (p9 | p2));
//int N1 = (p9 | p2) + (p3 | p4) + (p5 | p6) + (p7 | p8);
//int N2 = (p2 | p3) + (p4 | p5) + (p6 | p7) + (p8 | p9);
//int N = N1 < N2 ? N1 : N2;
//int m = iter == 0 ? ((p6 | p7 | (!p9)) & p8) : ((p2 | p3 | (!p5)) & p4);
//if ((C == 1) && ((N >= 2) && ((N <= 3)) & (m == 0))) value = 0;
// else value = 1;
});
}

// Parallelized iteration over pixels excluding the boundary
parallel_for_(Range(1, rows - 1), [&](const Range& range) {
for (int i = range.start; i < range.end; i++) {
const uchar* imgRow = img.ptr(i);
uchar* markerRow = marker.ptr(i);
for (int j = 1; j < cols - 1; j++) {
if (imgRow[j]) {
uchar p2 = imgRow[j - cols] != 0;
uchar p3 = imgRow[j - cols + 1] != 0;
uchar p4 = imgRow[j + 1] != 0;
uchar p5 = imgRow[j + cols + 1] != 0;
uchar p6 = imgRow[j + cols] != 0;
uchar p7 = imgRow[j + cols - 1] != 0;
uchar p8 = imgRow[j - 1] != 0;
uchar p9 = imgRow[j - cols - 1] != 0;

int neighbors = p9 | (p2 << 1) | (p3 << 2) | (p4 << 3) | (p5 << 4) | (p6 << 5) | (p7 << 6) | (p8 << 7);
uchar lut_value = lut[neighbors];

if (lut_value == 0)
{
markerRow[j] = lut_value;
changed = true;
}
}
}
}
});

img &= marker;
}

// Apply the thinning procedure to a given image
void thinning(InputArray input, OutputArray output, int thinningType){
Mat processed = input.getMat().clone();
CV_CheckTypeEQ(processed.type(), CV_8UC1, "");
// Enforce the range of the input image to be in between 0 - 255
processed /= 255;
Mat input_ = input.getMat();
CV_Assert(!input_.empty());
CV_CheckTypeEQ(input_.type(), CV_8UC1, "");

Mat processed = input_ / 255;
Mat prev = processed.clone();
Mat diff;

do {
thinningIteration(processed, 0, thinningType);
thinningIteration(processed, 1, thinningType);
absdiff(processed, prev, diff);
if (!hasNonZero(diff)) break;
processed.copyTo(prev);
}
while (true);
Mat marker;
Mat marker_inner = processed(Rect(1, 1, processed.cols - 2, processed.rows - 2));
copyMakeBorder(marker_inner, marker, 1, 1, 1, 1, BORDER_ISOLATED | BORDER_CONSTANT, Scalar(255));

processed *= 255;
const auto lutIter0 = (thinningType == THINNING_GUOHALL) ? lut_guo_iter0 : lut_zhang_iter0;
const auto lutIter1 = (thinningType == THINNING_GUOHALL) ? lut_guo_iter1 : lut_zhang_iter1;

output.assign(processed);
do {
bool changed0 = false;
bool changed1 = false;
thinningIteration(processed, marker, lutIter0, changed0);
thinningIteration(processed, marker, lutIter1, changed1);

if (changed0 | changed1)
processed.copyTo(prev);
else
break;
} while (true);

output.assign(processed * 255);
}

} //namespace ximgproc
Expand Down
56 changes: 22 additions & 34 deletions modules/ximgproc/test/test_thinning.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,52 +6,40 @@

namespace opencv_test { namespace {

static int createTestImage(Mat1b& src)
{
src = Mat1b::zeros(Size(256, 256));
// Create a corner point that should not be affected.
src(0, 0) = 255;

for (int x = 50; x < src.cols - 50; x += 50)
{
cv::circle(src, Point(x, x/2), 30 + x/2, Scalar(255), 5);
}
int src_pixels = countNonZero(src);
EXPECT_GT(src_pixels, 0);
return src_pixels;
}

TEST(ximgproc_Thinning, simple_ZHANGSUEN)
{
Mat1b src;
int src_pixels = createTestImage(src);
string dir = cvtest::TS::ptr()->get_data_path();
Mat src = imread(dir + "cv/ximgproc/sources/08.png", IMREAD_GRAYSCALE);
Mat dst,check_img;

Mat1b dst;
thinning(src, dst, THINNING_ZHANGSUEN);
int dst_pixels = countNonZero(dst);
EXPECT_LE(dst_pixels, src_pixels);
EXPECT_EQ(dst(0, 0), 255);

#if 0
imshow("src", src); imshow("dst", dst); waitKey();
#endif
check_img = imread(dir + "cv/ximgproc/results/Thinning_ZHANGSUEN.png", IMREAD_GRAYSCALE);
EXPECT_EQ(0, cvtest::norm(check_img, dst, NORM_INF));

dst = ~src;
thinning(dst, dst, THINNING_ZHANGSUEN);

check_img = imread(dir + "cv/ximgproc/results/Thinning_inv_ZHANGSUEN.png", IMREAD_GRAYSCALE);
EXPECT_EQ(0, cvtest::norm(check_img, dst, NORM_INF));
}

TEST(ximgproc_Thinning, simple_GUOHALL)
{
Mat1b src;
int src_pixels = createTestImage(src);
string dir = cvtest::TS::ptr()->get_data_path();
Mat src = imread(dir + "cv/ximgproc/sources/08.png", IMREAD_GRAYSCALE);
Mat dst,check_img;

Mat1b dst;
thinning(src, dst, THINNING_GUOHALL);
int dst_pixels = countNonZero(dst);
EXPECT_LE(dst_pixels, src_pixels);
EXPECT_EQ(dst(0, 0), 255);

#if 0
imshow("src", src); imshow("dst", dst); waitKey();
#endif
}
check_img = imread(dir + "cv/ximgproc/results/Thinning_GUOHALL.png", IMREAD_GRAYSCALE);
EXPECT_EQ(0, cvtest::norm(check_img, dst, NORM_INF));

dst = ~src;
thinning(dst, dst, THINNING_GUOHALL);

check_img = imread(dir + "cv/ximgproc/results/Thinning_inv_GUOHALL.png", IMREAD_GRAYSCALE);
EXPECT_EQ(0, cvtest::norm(check_img, dst, NORM_INF));
}

}} // namespace
Loading