--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////\r
+//\r
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\r
+//\r
+// By downloading, copying, installing or using the software you agree to this license.\r
+// If you do not agree to this license, do not download, install,\r
+// copy or use the software.\r
+//\r
+//\r
+// Intel License Agreement\r
+// For Open Source Computer Vision Library\r
+//\r
+// Copyright (C) 2000, Intel Corporation, all rights reserved.\r
+// Third party copyrights are property of their respective owners.\r
+//\r
+// Redistribution and use in source and binary forms, with or without modification,\r
+// are permitted provided that the following conditions are met:\r
+//\r
+// * Redistribution's of source code must retain the above copyright notice,\r
+// this list of conditions and the following disclaimer.\r
+//\r
+// * Redistribution's in binary form must reproduce the above copyright notice,\r
+// this list of conditions and the following disclaimer in the documentation\r
+// and/or other materials provided with the distribution.\r
+//\r
+// * The name of Intel Corporation may not be used to endorse or promote products\r
+// derived from this software without specific prior written permission.\r
+//\r
+// This software is provided by the copyright holders and contributors "as is" and\r
+// any express or implied warranties, including, but not limited to, the implied\r
+// warranties of merchantability and fitness for a particular purpose are disclaimed.\r
+// In no event shall the Intel Corporation or contributors be liable for any direct,\r
+// indirect, incidental, special, exemplary, or consequential damages\r
+// (including, but not limited to, procurement of substitute goods or services;\r
+// loss of use, data, or profits; or business interruption) however caused\r
+// and on any theory of liability, whether in contract, strict liability,\r
+// or tort (including negligence or otherwise) arising in any way out of\r
+// the use of this software, even if advised of the possibility of such damage.\r
+//\r
+//M*/\r
+#include "_cv.h"\r
+\r
+#define ICV_DIST_SHIFT 16\r
+#define ICV_INIT_DIST0 (INT_MAX >> 2)\r
+\r
+static CvStatus\r
+icvInitTopBottom( int* temp, int tempstep, CvSize size, int border )\r
+{\r
+ int i, j;\r
+ for( i = 0; i < border; i++ )\r
+ {\r
+ int* ttop = (int*)(temp + i*tempstep);\r
+ int* tbottom = (int*)(temp + (size.height + border*2 - i - 1)*tempstep);\r
+ \r
+ for( j = 0; j < size.width + border*2; j++ )\r
+ {\r
+ ttop[j] = ICV_INIT_DIST0;\r
+ tbottom[j] = ICV_INIT_DIST0;\r
+ }\r
+ }\r
+\r
+ return CV_OK;\r
+}\r
+\r
+\r
+static CvStatus CV_STDCALL\r
+icvDistanceTransform_3x3_C1R( const uchar* src, int srcstep, int* temp,\r
+ int step, float* dist, int dststep, CvSize size, const float* metrics )\r
+{\r
+ const int BORDER = 1;\r
+ int i, j;\r
+ const int HV_DIST = CV_FLT_TO_FIX( metrics[0], ICV_DIST_SHIFT );\r
+ const int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], ICV_DIST_SHIFT );\r
+ const float scale = 1.f/(1 << ICV_DIST_SHIFT);\r
+\r
+ srcstep /= sizeof(src[0]);\r
+ step /= sizeof(temp[0]);\r
+ dststep /= sizeof(dist[0]);\r
+\r
+ icvInitTopBottom( temp, step, size, BORDER );\r
+\r
+ // forward pass\r
+ for( i = 0; i < size.height; i++ )\r
+ {\r
+ const uchar* s = src + i*srcstep;\r
+ int* tmp = (int*)(temp + (i+BORDER)*step) + BORDER;\r
+\r
+ for( j = 0; j < BORDER; j++ )\r
+ tmp[-j-1] = tmp[size.width + j] = ICV_INIT_DIST0;\r
+ \r
+ for( j = 0; j < size.width; j++ )\r
+ {\r
+ if( !s[j] )\r
+ tmp[j] = 0;\r
+ else\r
+ {\r
+ int t0 = tmp[j-step-1] + DIAG_DIST;\r
+ int t = tmp[j-step] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-step+1] + DIAG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-1] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ tmp[j] = t0;\r
+ }\r
+ }\r
+ }\r
+\r
+ // backward pass\r
+ for( i = size.height - 1; i >= 0; i-- )\r
+ {\r
+ float* d = (float*)(dist + i*dststep);\r
+ int* tmp = (int*)(temp + (i+BORDER)*step) + BORDER;\r
+ \r
+ for( j = size.width - 1; j >= 0; j-- )\r
+ {\r
+ int t0 = tmp[j];\r
+ if( t0 > HV_DIST )\r
+ {\r
+ int t = tmp[j+step+1] + DIAG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step-1] + DIAG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+1] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ tmp[j] = t0;\r
+ }\r
+ d[j] = (float)(t0 * scale);\r
+ }\r
+ }\r
+\r
+ return CV_OK;\r
+}\r
+\r
+\r
+static CvStatus CV_STDCALL\r
+icvDistanceTransform_5x5_C1R( const uchar* src, int srcstep, int* temp,\r
+ int step, float* dist, int dststep, CvSize size, const float* metrics )\r
+{\r
+ const int BORDER = 2;\r
+ int i, j;\r
+ const int HV_DIST = CV_FLT_TO_FIX( metrics[0], ICV_DIST_SHIFT );\r
+ const int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], ICV_DIST_SHIFT );\r
+ const int LONG_DIST = CV_FLT_TO_FIX( metrics[2], ICV_DIST_SHIFT );\r
+ const float scale = 1.f/(1 << ICV_DIST_SHIFT);\r
+\r
+ srcstep /= sizeof(src[0]);\r
+ step /= sizeof(temp[0]);\r
+ dststep /= sizeof(dist[0]);\r
+\r
+ icvInitTopBottom( temp, step, size, BORDER );\r
+\r
+ // forward pass\r
+ for( i = 0; i < size.height; i++ )\r
+ {\r
+ const uchar* s = src + i*srcstep;\r
+ int* tmp = (int*)(temp + (i+BORDER)*step) + BORDER;\r
+\r
+ for( j = 0; j < BORDER; j++ )\r
+ tmp[-j-1] = tmp[size.width + j] = ICV_INIT_DIST0;\r
+ \r
+ for( j = 0; j < size.width; j++ )\r
+ {\r
+ if( !s[j] )\r
+ tmp[j] = 0;\r
+ else\r
+ {\r
+ int t0 = tmp[j-step*2-1] + LONG_DIST;\r
+ int t = tmp[j-step*2+1] + LONG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-step-2] + LONG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-step-1] + DIAG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-step] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-step+1] + DIAG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-step+2] + LONG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j-1] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ tmp[j] = t0;\r
+ }\r
+ }\r
+ }\r
+\r
+ // backward pass\r
+ for( i = size.height - 1; i >= 0; i-- )\r
+ {\r
+ float* d = (float*)(dist + i*dststep);\r
+ int* tmp = (int*)(temp + (i+BORDER)*step) + BORDER;\r
+ \r
+ for( j = size.width - 1; j >= 0; j-- )\r
+ {\r
+ int t0 = tmp[j];\r
+ if( t0 > HV_DIST )\r
+ {\r
+ int t = tmp[j+step*2+1] + LONG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step*2-1] + LONG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step+2] + LONG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step+1] + DIAG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step-1] + DIAG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+step-2] + LONG_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ t = tmp[j+1] + HV_DIST;\r
+ if( t0 > t ) t0 = t;\r
+ tmp[j] = t0;\r
+ }\r
+ d[j] = (float)(t0 * scale);\r
+ }\r
+ }\r
+\r
+ return CV_OK;\r
+}\r
+\r
+\r
+static CvStatus CV_STDCALL\r
+icvDistanceTransformEx_5x5_C1R( const uchar* src, int srcstep, int* temp,\r
+ int step, float* dist, int dststep, int* labels, int lstep,\r
+ CvSize size, const float* metrics )\r
+{\r
+ const int BORDER = 2;\r
+ \r
+ int i, j;\r
+ const int HV_DIST = CV_FLT_TO_FIX( metrics[0], ICV_DIST_SHIFT );\r
+ const int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], ICV_DIST_SHIFT );\r
+ const int LONG_DIST = CV_FLT_TO_FIX( metrics[2], ICV_DIST_SHIFT );\r
+ const float scale = 1.f/(1 << ICV_DIST_SHIFT);\r
+\r
+ srcstep /= sizeof(src[0]);\r
+ step /= sizeof(temp[0]);\r
+ dststep /= sizeof(dist[0]);\r
+ lstep /= sizeof(labels[0]);\r
+\r
+ icvInitTopBottom( temp, step, size, BORDER );\r
+\r
+ // forward pass\r
+ for( i = 0; i < size.height; i++ )\r
+ {\r
+ const uchar* s = src + i*srcstep;\r
+ int* tmp = (int*)(temp + (i+BORDER)*step) + BORDER;\r
+ int* lls = (int*)(labels + i*lstep);\r
+\r
+ for( j = 0; j < BORDER; j++ )\r
+ tmp[-j-1] = tmp[size.width + j] = ICV_INIT_DIST0;\r
+ \r
+ for( j = 0; j < size.width; j++ )\r
+ {\r
+ if( !s[j] )\r
+ {\r
+ tmp[j] = 0;\r
+ //assert( lls[j] != 0 );\r
+ }\r
+ else\r
+ {\r
+ int t0 = ICV_INIT_DIST0, t;\r
+ int l0 = 0;\r
+\r
+ t = tmp[j-step*2-1] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-lstep*2-1];\r
+ }\r
+ t = tmp[j-step*2+1] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-lstep*2+1];\r
+ }\r
+ t = tmp[j-step-2] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-lstep-2];\r
+ }\r
+ t = tmp[j-step-1] + DIAG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-lstep-1];\r
+ }\r
+ t = tmp[j-step] + HV_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-lstep];\r
+ }\r
+ t = tmp[j-step+1] + DIAG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-lstep+1];\r
+ }\r
+ t = tmp[j-step+2] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-lstep+2];\r
+ }\r
+ t = tmp[j-1] + HV_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j-1];\r
+ }\r
+\r
+ tmp[j] = t0;\r
+ lls[j] = l0;\r
+ }\r
+ }\r
+ }\r
+\r
+ // backward pass\r
+ for( i = size.height - 1; i >= 0; i-- )\r
+ {\r
+ float* d = (float*)(dist + i*dststep);\r
+ int* tmp = (int*)(temp + (i+BORDER)*step) + BORDER;\r
+ int* lls = (int*)(labels + i*lstep);\r
+ \r
+ for( j = size.width - 1; j >= 0; j-- )\r
+ {\r
+ int t0 = tmp[j];\r
+ int l0 = lls[j];\r
+ if( t0 > HV_DIST )\r
+ {\r
+ int t = tmp[j+step*2+1] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+lstep*2+1];\r
+ }\r
+ t = tmp[j+step*2-1] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+lstep*2-1];\r
+ }\r
+ t = tmp[j+step+2] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+lstep+2];\r
+ }\r
+ t = tmp[j+step+1] + DIAG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+lstep+1];\r
+ }\r
+ t = tmp[j+step] + HV_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+lstep];\r
+ }\r
+ t = tmp[j+step-1] + DIAG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+lstep-1];\r
+ }\r
+ t = tmp[j+step-2] + LONG_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+lstep-2];\r
+ }\r
+ t = tmp[j+1] + HV_DIST;\r
+ if( t0 > t )\r
+ {\r
+ t0 = t;\r
+ l0 = lls[j+1];\r
+ }\r
+ tmp[j] = t0;\r
+ lls[j] = l0;\r
+ }\r
+ d[j] = (float)(t0 * scale);\r
+ }\r
+ }\r
+\r
+ return CV_OK;\r
+}\r
+\r
+\r
+static CvStatus\r
+icvGetDistanceTransformMask( int maskType, float *metrics )\r
+{\r
+ if( !metrics )\r
+ return CV_NULLPTR_ERR;\r
+\r
+ switch (maskType)\r
+ {\r
+ case 30:\r
+ metrics[0] = 1.0f;\r
+ metrics[1] = 1.0f;\r
+ break;\r
+\r
+ case 31:\r
+ metrics[0] = 1.0f;\r
+ metrics[1] = 2.0f;\r
+ break;\r
+\r
+ case 32:\r
+ metrics[0] = 0.955f;\r
+ metrics[1] = 1.3693f;\r
+ break;\r
+\r
+ case 50:\r
+ metrics[0] = 1.0f;\r
+ metrics[1] = 1.0f;\r
+ metrics[2] = 2.0f;\r
+ break;\r
+\r
+ case 51:\r
+ metrics[0] = 1.0f;\r
+ metrics[1] = 2.0f;\r
+ metrics[2] = 3.0f;\r
+ break;\r
+\r
+ case 52:\r
+ metrics[0] = 1.0f;\r
+ metrics[1] = 1.4f;\r
+ metrics[2] = 2.1969f;\r
+ break;\r
+ default:\r
+ return CV_BADRANGE_ERR;\r
+ }\r
+\r
+ return CV_OK;\r
+}\r
+\r
+\r
+static void\r
+icvTrueDistTrans( const CvMat* src, CvMat* dst )\r
+{\r
+ CvMat* buffer = 0;\r
+\r
+ CV_FUNCNAME( "cvDistTransform2" );\r
+\r
+ __BEGIN__;\r
+\r
+ int i, m, n;\r
+ int sstep, dstep;\r
+ const float inf = 1e6f;\r
+ int thread_count = cvGetNumThreads();\r
+ int pass1_sz, pass2_sz;\r
+\r
+ if( !CV_ARE_SIZES_EQ( src, dst ))\r
+ CV_ERROR( CV_StsUnmatchedSizes, "" );\r
+\r
+ if( CV_MAT_TYPE(src->type) != CV_8UC1 ||\r
+ CV_MAT_TYPE(dst->type) != CV_32FC1 )\r
+ CV_ERROR( CV_StsUnsupportedFormat,\r
+ "The input image must have 8uC1 type and the output one must have 32fC1 type" );\r
+\r
+ m = src->rows;\r
+ n = src->cols;\r
+\r
+ // (see stage 1 below):\r
+ // sqr_tab: 2*m, sat_tab: 3*m + 1, d: m*thread_count,\r
+ pass1_sz = src->rows*(5 + thread_count) + 1;\r
+ // (see stage 2):\r
+ // sqr_tab & inv_tab: n each; f & v: n*thread_count each; z: (n+1)*thread_count\r
+ pass2_sz = src->cols*(2 + thread_count*3) + thread_count;\r
+ CV_CALL( buffer = cvCreateMat( 1, MAX(pass1_sz, pass2_sz), CV_32FC1 ));\r
+\r
+ sstep = src->step;\r
+ dstep = dst->step / sizeof(float);\r
+\r
+ // stage 1: compute 1d distance transform of each column\r
+ {\r
+ float* sqr_tab = buffer->data.fl;\r
+ int* sat_tab = (int*)(sqr_tab + m*2);\r
+ const int shift = m*2;\r
+\r
+ for( i = 0; i < m; i++ )\r
+ sqr_tab[i] = (float)(i*i);\r
+ for( i = m; i < m*2; i++ )\r
+ sqr_tab[i] = inf;\r
+ for( i = 0; i < shift; i++ )\r
+ sat_tab[i] = 0;\r
+ for( ; i <= m*3; i++ )\r
+ sat_tab[i] = i - shift;\r
+\r
+#ifdef _OPENMP\r
+ #pragma omp parallel for num_threads(thread_count)\r
+#endif\r
+ for( i = 0; i < n; i++ )\r
+ {\r
+ const uchar* sptr = src->data.ptr + i + (m-1)*sstep;\r
+ float* dptr = dst->data.fl + i;\r
+ int* d = (int*)(sat_tab + m*3+1+m*cvGetThreadNum());\r
+ int j, dist = m-1;\r
+\r
+ for( j = m-1; j >= 0; j--, sptr -= sstep )\r
+ {\r
+ dist = (dist + 1) & (sptr[0] == 0 ? 0 : -1);\r
+ d[j] = dist;\r
+ }\r
+\r
+ dist = m-1;\r
+ for( j = 0; j < m; j++, dptr += dstep )\r
+ {\r
+ dist = dist + 1 - sat_tab[dist + 1 - d[j] + shift];\r
+ d[j] = dist;\r
+ dptr[0] = sqr_tab[dist];\r
+ }\r
+ }\r
+ }\r
+\r
+ // stage 2: compute modified distance transform for each row\r
+ {\r
+ float* inv_tab = buffer->data.fl;\r
+ float* sqr_tab = inv_tab + n;\r
+\r
+ inv_tab[0] = sqr_tab[0] = 0.f;\r
+ for( i = 1; i < n; i++ )\r
+ {\r
+ inv_tab[i] = (float)(0.5/i);\r
+ sqr_tab[i] = (float)(i*i);\r
+ }\r
+\r
+#ifdef _OPENMP\r
+ #pragma omp parallel for num_threads(thread_count) schedule(dynamic)\r
+#endif\r
+ for( i = 0; i < m; i++ )\r
+ {\r
+ float* d = (float*)(dst->data.ptr + i*dst->step);\r
+ float* f = sqr_tab + n + (n*3+1)*cvGetThreadNum();\r
+ float* z = f + n;\r
+ int* v = (int*)(z + n + 1);\r
+ int p, q, k;\r
+\r
+ v[0] = 0;\r
+ z[0] = -inf;\r
+ z[1] = inf;\r
+ f[0] = d[0];\r
+\r
+ for( q = 1, k = 0; q < n; q++ )\r
+ {\r
+ float fq = d[q];\r
+ f[q] = fq;\r
+\r
+ for(;;k--)\r
+ {\r
+ p = v[k];\r
+ float s = (fq + sqr_tab[q] - d[p] - sqr_tab[p])*inv_tab[q - p];\r
+ if( s > z[k] )\r
+ {\r
+ k++;\r
+ v[k] = q;\r
+ z[k] = s;\r
+ z[k+1] = inf;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ for( q = 0, k = 0; q < n; q++ )\r
+ {\r
+ while( z[k+1] < q )\r
+ k++;\r
+ p = v[k];\r
+ d[q] = sqr_tab[abs(q - p)] + f[p];\r
+ }\r
+ }\r
+ }\r
+\r
+ cvPow( dst, dst, 0.5 );\r
+\r
+ __END__;\r
+\r
+ cvReleaseMat( &buffer );\r
+}\r
+\r
+\r
+/*********************************** IPP functions *********************************/\r
+\r
+typedef CvStatus (CV_STDCALL * CvIPPDistTransFunc)( const uchar* src, int srcstep,\r
+ void* dst, int dststep,\r
+ CvSize size, const void* metrics );\r
+\r
+typedef CvStatus (CV_STDCALL * CvIPPDistTransFunc2)( uchar* src, int srcstep,\r
+ CvSize size, const int* metrics );\r
+\r
+/***********************************************************************************/\r
+\r
+typedef CvStatus (CV_STDCALL * CvDistTransFunc)( const uchar* src, int srcstep,\r
+ int* temp, int tempstep,\r
+ float* dst, int dststep,\r
+ CvSize size, const float* metrics );\r
+\r
+\r
+/****************************************************************************************\\r
+ Non-inplace and Inplace 8u->8u Distance Transform for CityBlock (a.k.a. L1) metric\r
+ (C) 2006 by Jay Stavinzky.\r
+\****************************************************************************************/\r
+\r
+//BEGIN ATS ADDITION\r
+/* 8-bit grayscale distance transform function */\r
+static void\r
+icvDistanceATS_L1_8u( const CvMat* src, CvMat* dst )\r
+{\r
+ CV_FUNCNAME( "cvDistanceATS" );\r
+\r
+ __BEGIN__;\r
+\r
+ int width = src->cols, height = src->rows;\r
+\r
+ int a;\r
+ uchar lut[256];\r
+ int x, y;\r
+ \r
+ const uchar *sbase = src->data.ptr;\r
+ uchar *dbase = dst->data.ptr;\r
+ int srcstep = src->step;\r
+ int dststep = dst->step;\r
+\r
+ CV_ASSERT( CV_IS_MASK_ARR( src ) && CV_MAT_TYPE( dst->type ) == CV_8UC1 );\r
+ CV_ASSERT( CV_ARE_SIZES_EQ( src, dst ));\r
+\r
+ ////////////////////// forward scan ////////////////////////\r
+ for( x = 0; x < 256; x++ )\r
+ lut[x] = CV_CAST_8U(x+1);\r
+\r
+ //init first pixel to max (we're going to be skipping it)\r
+ dbase[0] = (uchar)(sbase[0] == 0 ? 0 : 255);\r
+\r
+ //first row (scan west only, skip first pixel)\r
+ for( x = 1; x < width; x++ )\r
+ dbase[x] = (uchar)(sbase[x] == 0 ? 0 : lut[dbase[x-1]]);\r
+\r
+ for( y = 1; y < height; y++ )\r
+ {\r
+ sbase += srcstep;\r
+ dbase += dststep;\r
+\r
+ //for left edge, scan north only\r
+ a = sbase[0] == 0 ? 0 : lut[dbase[-dststep]];\r
+ dbase[0] = (uchar)a;\r
+\r
+ for( x = 1; x < width; x++ )\r
+ {\r
+ a = sbase[x] == 0 ? 0 : lut[MIN(a, dbase[x - dststep])];\r
+ dbase[x] = (uchar)a;\r
+ }\r
+ }\r
+\r
+ ////////////////////// backward scan ///////////////////////\r
+\r
+ a = dbase[width-1];\r
+\r
+ // do last row east pixel scan here (skip bottom right pixel)\r
+ for( x = width - 2; x >= 0; x-- )\r
+ {\r
+ a = lut[a];\r
+ dbase[x] = (uchar)(CV_CALC_MIN_8U(a, dbase[x]));\r
+ }\r
+\r
+ // right edge is the only error case\r
+ for( y = height - 2; y >= 0; y-- )\r
+ {\r
+ dbase -= dststep;\r
+\r
+ // do right edge\r
+ a = lut[dbase[width-1+dststep]];\r
+ dbase[width-1] = (uchar)(MIN(a, dbase[width-1]));\r
+\r
+ for( x = width - 2; x >= 0; x-- )\r
+ {\r
+ int b = dbase[x+dststep];\r
+ a = lut[MIN(a, b)];\r
+ dbase[x] = (uchar)(MIN(a, dbase[x]));\r
+ }\r
+ }\r
+\r
+ __END__;\r
+}\r
+//END ATS ADDITION\r
+\r
+\r
+/* Wrapper function for distance transform group */\r
+CV_IMPL void\r
+cvDistTransform( const void* srcarr, void* dstarr,\r
+ int distType, int maskSize,\r
+ const float *mask,\r
+ void* labelsarr )\r
+{\r
+ CvMat* temp = 0;\r
+ CvMat* src_copy = 0;\r
+ CvMemStorage* st = 0;\r
+ \r
+ CV_FUNCNAME( "cvDistTransform" );\r
+\r
+ __BEGIN__;\r
+\r
+ float _mask[5] = {0};\r
+ CvMat srcstub, *src = (CvMat*)srcarr;\r
+ CvMat dststub, *dst = (CvMat*)dstarr;\r
+ CvMat lstub, *labels = (CvMat*)labelsarr;\r
+ CvSize size;\r
+ //CvIPPDistTransFunc ipp_func = 0;\r
+ //CvIPPDistTransFunc2 ipp_inp_func = 0;\r
+\r
+ CV_CALL( src = cvGetMat( src, &srcstub ));\r
+ CV_CALL( dst = cvGetMat( dst, &dststub ));\r
+\r
+ if( !CV_IS_MASK_ARR( src ) || (CV_MAT_TYPE( dst->type ) != CV_32FC1 &&\r
+ (CV_MAT_TYPE(dst->type) != CV_8UC1 || distType != CV_DIST_L1 || labels)) )\r
+ CV_ERROR( CV_StsUnsupportedFormat,\r
+ "source image must be 8uC1 and the distance map must be 32fC1 "\r
+ "(or 8uC1 in case of simple L1 distance transform)" );\r
+\r
+ if( !CV_ARE_SIZES_EQ( src, dst ))\r
+ CV_ERROR( CV_StsUnmatchedSizes, "the source and the destination images must be of the same size" );\r
+\r
+ if( maskSize != CV_DIST_MASK_3 && maskSize != CV_DIST_MASK_5 && maskSize != CV_DIST_MASK_PRECISE )\r
+ CV_ERROR( CV_StsBadSize, "Mask size should be 3 or 5 or 0 (presize)" );\r
+\r
+ if( distType == CV_DIST_C || distType == CV_DIST_L1 )\r
+ maskSize = !labels ? CV_DIST_MASK_3 : CV_DIST_MASK_5;\r
+ else if( distType == CV_DIST_L2 && labels )\r
+ maskSize = CV_DIST_MASK_5;\r
+\r
+ if( maskSize == CV_DIST_MASK_PRECISE )\r
+ {\r
+ CV_CALL( icvTrueDistTrans( src, dst ));\r
+ EXIT;\r
+ }\r
+ \r
+ if( labels )\r
+ {\r
+ CV_CALL( labels = cvGetMat( labels, &lstub ));\r
+ if( CV_MAT_TYPE( labels->type ) != CV_32SC1 )\r
+ CV_ERROR( CV_StsUnsupportedFormat, "the output array of labels must be 32sC1" );\r
+\r
+ if( !CV_ARE_SIZES_EQ( labels, dst ))\r
+ CV_ERROR( CV_StsUnmatchedSizes, "the array of labels has a different size" );\r
+\r
+ if( maskSize == CV_DIST_MASK_3 )\r
+ CV_ERROR( CV_StsNotImplemented,\r
+ "3x3 mask can not be used for \"labeled\" distance transform. Use 5x5 mask" );\r
+ }\r
+\r
+ if( distType == CV_DIST_C || distType == CV_DIST_L1 || distType == CV_DIST_L2 )\r
+ {\r
+ icvGetDistanceTransformMask( (distType == CV_DIST_C ? 0 :\r
+ distType == CV_DIST_L1 ? 1 : 2) + maskSize*10, _mask );\r
+ }\r
+ else if( distType == CV_DIST_USER )\r
+ {\r
+ if( !mask )\r
+ CV_ERROR( CV_StsNullPtr, "" );\r
+\r
+ memcpy( _mask, mask, (maskSize/2 + 1)*sizeof(float));\r
+ }\r
+\r
+ /*if( !labels )\r
+ {\r
+ if( CV_MAT_TYPE(dst->type) == CV_32FC1 )\r
+ ipp_func = (CvIPPDistTransFunc)(maskSize == CV_DIST_MASK_3 ?\r
+ icvDistanceTransform_3x3_8u32f_C1R_p : icvDistanceTransform_5x5_8u32f_C1R_p);\r
+ else if( src->data.ptr != dst->data.ptr )\r
+ ipp_func = (CvIPPDistTransFunc)icvDistanceTransform_3x3_8u_C1R_p;\r
+ else\r
+ ipp_inp_func = icvDistanceTransform_3x3_8u_C1IR_p;\r
+ }*/\r
+\r
+ size = cvGetMatSize(src);\r
+\r
+ /*if( (ipp_func || ipp_inp_func) && src->cols >= 4 && src->rows >= 2 )\r
+ {\r
+ int _imask[3];\r
+ _imask[0] = cvRound(_mask[0]);\r
+ _imask[1] = cvRound(_mask[1]);\r
+ _imask[2] = cvRound(_mask[2]);\r
+\r
+ if( ipp_func )\r
+ {\r
+ IPPI_CALL( ipp_func( src->data.ptr, src->step,\r
+ dst->data.fl, dst->step, size,\r
+ CV_MAT_TYPE(dst->type) == CV_8UC1 ?\r
+ (void*)_imask : (void*)_mask ));\r
+ }\r
+ else\r
+ {\r
+ IPPI_CALL( ipp_inp_func( src->data.ptr, src->step, size, _imask ));\r
+ }\r
+ }\r
+ else*/ if( CV_MAT_TYPE(dst->type) == CV_8UC1 )\r
+ {\r
+ CV_CALL( icvDistanceATS_L1_8u( src, dst ));\r
+ }\r
+ else\r
+ {\r
+ int border = maskSize == CV_DIST_MASK_3 ? 1 : 2;\r
+ CV_CALL( temp = cvCreateMat( size.height + border*2, size.width + border*2, CV_32SC1 ));\r
+\r
+ if( !labels )\r
+ {\r
+ CvDistTransFunc func = maskSize == CV_DIST_MASK_3 ?\r
+ icvDistanceTransform_3x3_C1R :\r
+ icvDistanceTransform_5x5_C1R;\r
+\r
+ func( src->data.ptr, src->step, temp->data.i, temp->step,\r
+ dst->data.fl, dst->step, size, _mask );\r
+ }\r
+ else\r
+ {\r
+ CvSeq *contours = 0;\r
+ CvPoint top_left = {0,0}, bottom_right = {size.width-1,size.height-1};\r
+ int label;\r
+\r
+ CV_CALL( st = cvCreateMemStorage() );\r
+ CV_CALL( src_copy = cvCreateMat( size.height, size.width, src->type ));\r
+ cvCmpS( src, 0, src_copy, CV_CMP_EQ );\r
+ cvFindContours( src_copy, st, &contours, sizeof(CvContour),\r
+ CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );\r
+ cvZero( labels );\r
+ for( label = 1; contours != 0; contours = contours->h_next, label++ )\r
+ {\r
+ CvScalar area_color = cvScalarAll(label);\r
+ cvDrawContours( labels, contours, area_color, area_color, -255, -1, 8 );\r
+ }\r
+\r
+ cvCopy( src, src_copy );\r
+ cvRectangle( src_copy, top_left, bottom_right, cvScalarAll(255), 1, 8 );\r
+\r
+ icvDistanceTransformEx_5x5_C1R( src_copy->data.ptr, src_copy->step, temp->data.i, temp->step,\r
+ dst->data.fl, dst->step, labels->data.i, labels->step, size, _mask );\r
+ }\r
+ }\r
+\r
+ __END__;\r
+\r
+ cvReleaseMat( &temp );\r
+ cvReleaseMat( &src_copy );\r
+ cvReleaseMemStorage( &st );\r
+}\r
+\r
+void cv::distanceTransform( const Mat& src, Mat& dst, Mat& labels,\r
+ int distanceType, int maskSize )\r
+{\r
+ dst.create(src.size(), CV_32F);\r
+ dst.create(src.size(), CV_32S);\r
+ CvMat _src = src, _dst = dst, _labels = labels;\r
+ cvDistTransform(&_src, &_dst, distanceType, maskSize, 0, &_labels);\r
+}\r
+\r
+void cv::distanceTransform( const Mat& src, Mat& dst,\r
+ int distanceType, int maskSize )\r
+{\r
+ dst.create(src.size(), CV_32F);\r
+ CvMat _src = src, _dst = dst;\r
+ cvDistTransform(&_src, &_dst, distanceType, maskSize, 0, 0);\r
+}\r
+\r
+/* End of file. */\r
projects / opencv / blobdiff