--- /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
+\r
+#include "_cv.h"\r
+\r
+typedef struct CvFFillSegment\r
+{\r
+ ushort y;\r
+ ushort l;\r
+ ushort r;\r
+ ushort prevl;\r
+ ushort prevr;\r
+ short dir;\r
+}\r
+CvFFillSegment;\r
+\r
+#define UP 1\r
+#define DOWN -1\r
+\r
+#define ICV_PUSH( Y, L, R, PREV_L, PREV_R, DIR )\\r
+{ \\r
+ tail->y = (ushort)(Y); \\r
+ tail->l = (ushort)(L); \\r
+ tail->r = (ushort)(R); \\r
+ tail->prevl = (ushort)(PREV_L); \\r
+ tail->prevr = (ushort)(PREV_R); \\r
+ tail->dir = (short)(DIR); \\r
+ if( ++tail >= buffer_end ) \\r
+ tail = buffer; \\r
+}\r
+\r
+\r
+#define ICV_POP( Y, L, R, PREV_L, PREV_R, DIR ) \\r
+{ \\r
+ Y = head->y; \\r
+ L = head->l; \\r
+ R = head->r; \\r
+ PREV_L = head->prevl; \\r
+ PREV_R = head->prevr; \\r
+ DIR = head->dir; \\r
+ if( ++head >= buffer_end ) \\r
+ head = buffer; \\r
+}\r
+\r
+\r
+#define ICV_EQ_C3( p1, p2 ) \\r
+ ((p1)[0] == (p2)[0] && (p1)[1] == (p2)[1] && (p1)[2] == (p2)[2])\r
+\r
+#define ICV_SET_C3( p, q ) \\r
+ ((p)[0] = (q)[0], (p)[1] = (q)[1], (p)[2] = (q)[2])\r
+\r
+/****************************************************************************************\\r
+* Simple Floodfill (repainting single-color connected component) *\r
+\****************************************************************************************/\r
+\r
+static CvStatus\r
+icvFloodFill_8u_CnIR( uchar* pImage, int step, CvSize roi, CvPoint seed,\r
+ uchar* _newVal, CvConnectedComp* region, int flags,\r
+ CvFFillSegment* buffer, int buffer_size, int cn )\r
+{\r
+ uchar* img = pImage + step * seed.y;\r
+ int i, L, R;\r
+ int area = 0;\r
+ int val0[] = {0,0,0};\r
+ uchar newVal[] = {0,0,0};\r
+ int XMin, XMax, YMin = seed.y, YMax = seed.y;\r
+ int _8_connectivity = (flags & 255) == 8;\r
+ CvFFillSegment* buffer_end = buffer + buffer_size, *head = buffer, *tail = buffer;\r
+\r
+ L = R = XMin = XMax = seed.x;\r
+\r
+ if( cn == 1 )\r
+ {\r
+ val0[0] = img[L];\r
+ newVal[0] = _newVal[0];\r
+\r
+ img[L] = newVal[0];\r
+\r
+ while( ++R < roi.width && img[R] == val0[0] )\r
+ img[R] = newVal[0];\r
+\r
+ while( --L >= 0 && img[L] == val0[0] )\r
+ img[L] = newVal[0];\r
+ }\r
+ else\r
+ {\r
+ assert( cn == 3 );\r
+ ICV_SET_C3( val0, img + L*3 );\r
+ ICV_SET_C3( newVal, _newVal );\r
+\r
+ ICV_SET_C3( img + L*3, newVal );\r
+\r
+ while( --L >= 0 && ICV_EQ_C3( img + L*3, val0 ))\r
+ ICV_SET_C3( img + L*3, newVal );\r
+\r
+ while( ++R < roi.width && ICV_EQ_C3( img + R*3, val0 ))\r
+ ICV_SET_C3( img + R*3, newVal );\r
+ }\r
+\r
+ XMax = --R;\r
+ XMin = ++L;\r
+ ICV_PUSH( seed.y, L, R, R + 1, R, UP );\r
+\r
+ while( head != tail )\r
+ {\r
+ int k, YC, PL, PR, dir;\r
+ ICV_POP( YC, L, R, PL, PR, dir );\r
+\r
+ int data[][3] =\r
+ {\r
+ {-dir, L - _8_connectivity, R + _8_connectivity},\r
+ {dir, L - _8_connectivity, PL - 1},\r
+ {dir, PR + 1, R + _8_connectivity}\r
+ };\r
+\r
+ if( region )\r
+ {\r
+ area += R - L + 1;\r
+\r
+ if( XMax < R ) XMax = R;\r
+ if( XMin > L ) XMin = L;\r
+ if( YMax < YC ) YMax = YC;\r
+ if( YMin > YC ) YMin = YC;\r
+ }\r
+\r
+ for( k = 0/*(unsigned)(YC - dir) >= (unsigned)roi.height*/; k < 3; k++ )\r
+ {\r
+ dir = data[k][0];\r
+ img = pImage + (YC + dir) * step;\r
+ int left = data[k][1];\r
+ int right = data[k][2];\r
+\r
+ if( (unsigned)(YC + dir) >= (unsigned)roi.height )\r
+ continue;\r
+\r
+ if( cn == 1 )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( (unsigned)i < (unsigned)roi.width && img[i] == val0[0] )\r
+ {\r
+ int j = i;\r
+ img[i] = newVal[0];\r
+ while( --j >= 0 && img[j] == val0[0] )\r
+ img[j] = newVal[0];\r
+\r
+ while( ++i < roi.width && img[i] == val0[0] )\r
+ img[i] = newVal[0];\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( (unsigned)i < (unsigned)roi.width && ICV_EQ_C3( img + i*3, val0 ))\r
+ {\r
+ int j = i;\r
+ ICV_SET_C3( img + i*3, newVal );\r
+ while( --j >= 0 && ICV_EQ_C3( img + j*3, val0 ))\r
+ ICV_SET_C3( img + j*3, newVal );\r
+\r
+ while( ++i < roi.width && ICV_EQ_C3( img + i*3, val0 ))\r
+ ICV_SET_C3( img + i*3, newVal );\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ if( region )\r
+ {\r
+ region->area = area;\r
+ region->rect.x = XMin;\r
+ region->rect.y = YMin;\r
+ region->rect.width = XMax - XMin + 1;\r
+ region->rect.height = YMax - YMin + 1;\r
+ region->value = cvScalar(newVal[0], newVal[1], newVal[2], 0);\r
+ }\r
+\r
+ return CV_NO_ERR;\r
+}\r
+\r
+\r
+/* because all the operations on floats that are done during non-gradient floodfill\r
+ are just copying and comparison on equality,\r
+ we can do the whole op on 32-bit integers instead */\r
+static CvStatus\r
+icvFloodFill_32f_CnIR( int* pImage, int step, CvSize roi, CvPoint seed,\r
+ int* _newVal, CvConnectedComp* region, int flags,\r
+ CvFFillSegment* buffer, int buffer_size, int cn )\r
+{\r
+ int* img = pImage + (step /= sizeof(pImage[0])) * seed.y;\r
+ int i, L, R;\r
+ int area = 0;\r
+ int val0[] = {0,0,0};\r
+ int newVal[] = {0,0,0};\r
+ int XMin, XMax, YMin = seed.y, YMax = seed.y;\r
+ int _8_connectivity = (flags & 255) == 8;\r
+ CvFFillSegment* buffer_end = buffer + buffer_size, *head = buffer, *tail = buffer;\r
+\r
+ L = R = XMin = XMax = seed.x;\r
+\r
+ if( cn == 1 )\r
+ {\r
+ val0[0] = img[L];\r
+ newVal[0] = _newVal[0];\r
+\r
+ img[L] = newVal[0];\r
+\r
+ while( ++R < roi.width && img[R] == val0[0] )\r
+ img[R] = newVal[0];\r
+\r
+ while( --L >= 0 && img[L] == val0[0] )\r
+ img[L] = newVal[0];\r
+ }\r
+ else\r
+ {\r
+ assert( cn == 3 );\r
+ ICV_SET_C3( val0, img + L*3 );\r
+ ICV_SET_C3( newVal, _newVal );\r
+\r
+ ICV_SET_C3( img + L*3, newVal );\r
+\r
+ while( --L >= 0 && ICV_EQ_C3( img + L*3, val0 ))\r
+ ICV_SET_C3( img + L*3, newVal );\r
+\r
+ while( ++R < roi.width && ICV_EQ_C3( img + R*3, val0 ))\r
+ ICV_SET_C3( img + R*3, newVal );\r
+ }\r
+\r
+ XMax = --R;\r
+ XMin = ++L;\r
+ ICV_PUSH( seed.y, L, R, R + 1, R, UP );\r
+\r
+ while( head != tail )\r
+ {\r
+ int k, YC, PL, PR, dir;\r
+ ICV_POP( YC, L, R, PL, PR, dir );\r
+\r
+ int data[][3] =\r
+ {\r
+ {-dir, L - _8_connectivity, R + _8_connectivity},\r
+ {dir, L - _8_connectivity, PL - 1},\r
+ {dir, PR + 1, R + _8_connectivity}\r
+ };\r
+\r
+ if( region )\r
+ {\r
+ area += R - L + 1;\r
+\r
+ if( XMax < R ) XMax = R;\r
+ if( XMin > L ) XMin = L;\r
+ if( YMax < YC ) YMax = YC;\r
+ if( YMin > YC ) YMin = YC;\r
+ }\r
+\r
+ for( k = 0/*(unsigned)(YC - dir) >= (unsigned)roi.height*/; k < 3; k++ )\r
+ {\r
+ dir = data[k][0];\r
+ img = pImage + (YC + dir) * step;\r
+ int left = data[k][1];\r
+ int right = data[k][2];\r
+\r
+ if( (unsigned)(YC + dir) >= (unsigned)roi.height )\r
+ continue;\r
+\r
+ if( cn == 1 )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( (unsigned)i < (unsigned)roi.width && img[i] == val0[0] )\r
+ {\r
+ int j = i;\r
+ img[i] = newVal[0];\r
+ while( --j >= 0 && img[j] == val0[0] )\r
+ img[j] = newVal[0];\r
+\r
+ while( ++i < roi.width && img[i] == val0[0] )\r
+ img[i] = newVal[0];\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( (unsigned)i < (unsigned)roi.width && ICV_EQ_C3( img + i*3, val0 ))\r
+ {\r
+ int j = i;\r
+ ICV_SET_C3( img + i*3, newVal );\r
+ while( --j >= 0 && ICV_EQ_C3( img + j*3, val0 ))\r
+ ICV_SET_C3( img + j*3, newVal );\r
+\r
+ while( ++i < roi.width && ICV_EQ_C3( img + i*3, val0 ))\r
+ ICV_SET_C3( img + i*3, newVal );\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ if( region )\r
+ {\r
+ Cv32suf v0, v1, v2;\r
+ region->area = area;\r
+ region->rect.x = XMin;\r
+ region->rect.y = YMin;\r
+ region->rect.width = XMax - XMin + 1;\r
+ region->rect.height = YMax - YMin + 1;\r
+ v0.i = newVal[0]; v1.i = newVal[1]; v2.i = newVal[2];\r
+ region->value = cvScalar( v0.f, v1.f, v2.f );\r
+ }\r
+\r
+ return CV_NO_ERR;\r
+}\r
+\r
+/****************************************************************************************\\r
+* Gradient Floodfill *\r
+\****************************************************************************************/\r
+\r
+#define DIFF_INT_C1(p1,p2) ((unsigned)((p1)[0] - (p2)[0] + d_lw[0]) <= interval[0])\r
+\r
+#define DIFF_INT_C3(p1,p2) ((unsigned)((p1)[0] - (p2)[0] + d_lw[0])<= interval[0] && \\r
+ (unsigned)((p1)[1] - (p2)[1] + d_lw[1])<= interval[1] && \\r
+ (unsigned)((p1)[2] - (p2)[2] + d_lw[2])<= interval[2])\r
+\r
+#define DIFF_FLT_C1(p1,p2) (fabs((p1)[0] - (p2)[0] + d_lw[0]) <= interval[0])\r
+\r
+#define DIFF_FLT_C3(p1,p2) (fabs((p1)[0] - (p2)[0] + d_lw[0]) <= interval[0] && \\r
+ fabs((p1)[1] - (p2)[1] + d_lw[1]) <= interval[1] && \\r
+ fabs((p1)[2] - (p2)[2] + d_lw[2]) <= interval[2])\r
+\r
+static CvStatus\r
+icvFloodFill_Grad_8u_CnIR( uchar* pImage, int step, uchar* pMask, int maskStep,\r
+ CvSize /*roi*/, CvPoint seed, uchar* _newVal, uchar* _d_lw,\r
+ uchar* _d_up, CvConnectedComp* region, int flags,\r
+ CvFFillSegment* buffer, int buffer_size, int cn )\r
+{\r
+ uchar* img = pImage + step*seed.y;\r
+ uchar* mask = (pMask += maskStep + 1) + maskStep*seed.y;\r
+ int i, L, R;\r
+ int area = 0;\r
+ int sum[] = {0,0,0}, val0[] = {0,0,0};\r
+ uchar newVal[] = {0,0,0};\r
+ int d_lw[] = {0,0,0};\r
+ unsigned interval[] = {0,0,0};\r
+ int XMin, XMax, YMin = seed.y, YMax = seed.y;\r
+ int _8_connectivity = (flags & 255) == 8;\r
+ int fixedRange = flags & CV_FLOODFILL_FIXED_RANGE;\r
+ int fillImage = (flags & CV_FLOODFILL_MASK_ONLY) == 0;\r
+ uchar newMaskVal = (uchar)(flags & 0xff00 ? flags >> 8 : 1);\r
+ CvFFillSegment* buffer_end = buffer + buffer_size, *head = buffer, *tail = buffer;\r
+\r
+ L = R = seed.x;\r
+ if( mask[L] )\r
+ return CV_OK;\r
+\r
+ mask[L] = newMaskVal;\r
+\r
+ for( i = 0; i < cn; i++ )\r
+ {\r
+ newVal[i] = _newVal[i];\r
+ d_lw[i] = _d_lw[i];\r
+ interval[i] = (unsigned)(_d_up[i] + _d_lw[i]);\r
+ if( fixedRange )\r
+ val0[i] = img[L*cn+i];\r
+ }\r
+\r
+ if( cn == 1 )\r
+ {\r
+ if( fixedRange )\r
+ {\r
+ while( !mask[R + 1] && DIFF_INT_C1( img + (R+1), val0 ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_INT_C1( img + (L-1), val0 ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ else\r
+ {\r
+ while( !mask[R + 1] && DIFF_INT_C1( img + (R+1), img + R ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_INT_C1( img + (L-1), img + L ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if( fixedRange )\r
+ {\r
+ while( !mask[R + 1] && DIFF_INT_C3( img + (R+1)*3, val0 ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_INT_C3( img + (L-1)*3, val0 ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ else\r
+ {\r
+ while( !mask[R + 1] && DIFF_INT_C3( img + (R+1)*3, img + R*3 ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_INT_C3( img + (L-1)*3, img + L*3 ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ }\r
+\r
+ XMax = R;\r
+ XMin = L;\r
+ ICV_PUSH( seed.y, L, R, R + 1, R, UP );\r
+\r
+ while( head != tail )\r
+ {\r
+ int k, YC, PL, PR, dir, curstep;\r
+ ICV_POP( YC, L, R, PL, PR, dir );\r
+\r
+ int data[][3] =\r
+ {\r
+ {-dir, L - _8_connectivity, R + _8_connectivity},\r
+ {dir, L - _8_connectivity, PL - 1},\r
+ {dir, PR + 1, R + _8_connectivity}\r
+ };\r
+\r
+ unsigned length = (unsigned)(R-L);\r
+\r
+ if( region )\r
+ {\r
+ area += (int)length + 1;\r
+\r
+ if( XMax < R ) XMax = R;\r
+ if( XMin > L ) XMin = L;\r
+ if( YMax < YC ) YMax = YC;\r
+ if( YMin > YC ) YMin = YC;\r
+ }\r
+\r
+ if( cn == 1 )\r
+ {\r
+ for( k = 0; k < 3; k++ )\r
+ {\r
+ dir = data[k][0];\r
+ curstep = dir * step;\r
+ img = pImage + (YC + dir) * step;\r
+ mask = pMask + (YC + dir) * maskStep;\r
+ int left = data[k][1];\r
+ int right = data[k][2];\r
+\r
+ if( fixedRange )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_INT_C1( img + i, val0 ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_INT_C1( img + j, val0 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] && DIFF_INT_C1( img + i, val0 ))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else if( !_8_connectivity )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_INT_C1( img + i, img - curstep + i ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_INT_C1( img + j, img + (j+1) ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ (DIFF_INT_C1( img + i, img + (i-1) ) ||\r
+ (DIFF_INT_C1( img + i, img + i - curstep) && i <= R)))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ int idx, val[1];\r
+\r
+ if( !mask[i] &&\r
+ (((val[0] = img[i],\r
+ (unsigned)(idx = i-L-1) <= length) &&\r
+ DIFF_INT_C1( val, img - curstep + (i-1))) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C1( val, img - curstep + i )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C1( val, img - curstep + (i+1) ))))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_INT_C1( img + j, img + (j+1) ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ ((val[0] = img[i],\r
+ DIFF_INT_C1( val, img + (i-1) )) ||\r
+ (((unsigned)(idx = i-L-1) <= length &&\r
+ DIFF_INT_C1( val, img - curstep + (i-1) ))) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C1( val, img - curstep + i )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C1( val, img - curstep + (i+1) ))))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ }\r
+\r
+ img = pImage + YC * step;\r
+ if( fillImage )\r
+ for( i = L; i <= R; i++ )\r
+ img[i] = newVal[0];\r
+ else if( region )\r
+ for( i = L; i <= R; i++ )\r
+ sum[0] += img[i];\r
+ }\r
+ else\r
+ {\r
+ for( k = 0; k < 3; k++ )\r
+ {\r
+ dir = data[k][0];\r
+ curstep = dir * step;\r
+ img = pImage + (YC + dir) * step;\r
+ mask = pMask + (YC + dir) * maskStep;\r
+ int left = data[k][1];\r
+ int right = data[k][2];\r
+\r
+ if( fixedRange )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_INT_C3( img + i*3, val0 ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_INT_C3( img + j*3, val0 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] && DIFF_INT_C3( img + i*3, val0 ))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else if( !_8_connectivity )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_INT_C3( img + i*3, img - curstep + i*3 ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_INT_C3( img + j*3, img + (j+1)*3 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ (DIFF_INT_C3( img + i*3, img + (i-1)*3 ) ||\r
+ (DIFF_INT_C3( img + i*3, img + i*3 - curstep) && i <= R)))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ int idx, val[3];\r
+\r
+ if( !mask[i] &&\r
+ (((ICV_SET_C3( val, img+i*3 ),\r
+ (unsigned)(idx = i-L-1) <= length) &&\r
+ DIFF_INT_C3( val, img - curstep + (i-1)*3 )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C3( val, img - curstep + i*3 )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C3( val, img - curstep + (i+1)*3 ))))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_INT_C3( img + j*3, img + (j+1)*3 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ ((ICV_SET_C3( val, img + i*3 ),\r
+ DIFF_INT_C3( val, img + (i-1)*3 )) ||\r
+ (((unsigned)(idx = i-L-1) <= length &&\r
+ DIFF_INT_C3( val, img - curstep + (i-1)*3 ))) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C3( val, img - curstep + i*3 )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_INT_C3( val, img - curstep + (i+1)*3 ))))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ }\r
+\r
+ img = pImage + YC * step;\r
+ if( fillImage )\r
+ for( i = L; i <= R; i++ )\r
+ ICV_SET_C3( img + i*3, newVal );\r
+ else if( region )\r
+ for( i = L; i <= R; i++ )\r
+ {\r
+ sum[0] += img[i*3];\r
+ sum[1] += img[i*3+1];\r
+ sum[2] += img[i*3+2];\r
+ }\r
+ }\r
+ }\r
+\r
+ if( region )\r
+ {\r
+ region->area = area;\r
+ region->rect.x = XMin;\r
+ region->rect.y = YMin;\r
+ region->rect.width = XMax - XMin + 1;\r
+ region->rect.height = YMax - YMin + 1;\r
+\r
+ if( fillImage )\r
+ region->value = cvScalar(newVal[0], newVal[1], newVal[2]);\r
+ else\r
+ {\r
+ double iarea = area ? 1./area : 0;\r
+ region->value = cvScalar(sum[0]*iarea, sum[1]*iarea, sum[2]*iarea);\r
+ }\r
+ }\r
+\r
+ return CV_NO_ERR;\r
+}\r
+\r
+\r
+static CvStatus\r
+icvFloodFill_Grad_32f_CnIR( float* pImage, int step, uchar* pMask, int maskStep,\r
+ CvSize /*roi*/, CvPoint seed, float* _newVal, float* _d_lw,\r
+ float* _d_up, CvConnectedComp* region, int flags,\r
+ CvFFillSegment* buffer, int buffer_size, int cn )\r
+{\r
+ float* img = pImage + (step /= sizeof(float))*seed.y;\r
+ uchar* mask = (pMask += maskStep + 1) + maskStep*seed.y;\r
+ int i, L, R;\r
+ int area = 0;\r
+ double sum[] = {0,0,0}, val0[] = {0,0,0};\r
+ float newVal[] = {0,0,0};\r
+ float d_lw[] = {0,0,0};\r
+ float interval[] = {0,0,0};\r
+ int XMin, XMax, YMin = seed.y, YMax = seed.y;\r
+ int _8_connectivity = (flags & 255) == 8;\r
+ int fixedRange = flags & CV_FLOODFILL_FIXED_RANGE;\r
+ int fillImage = (flags & CV_FLOODFILL_MASK_ONLY) == 0;\r
+ uchar newMaskVal = (uchar)(flags & 0xff00 ? flags >> 8 : 1);\r
+ CvFFillSegment* buffer_end = buffer + buffer_size, *head = buffer, *tail = buffer;\r
+\r
+ L = R = seed.x;\r
+ if( mask[L] )\r
+ return CV_OK;\r
+\r
+ mask[L] = newMaskVal;\r
+\r
+ for( i = 0; i < cn; i++ )\r
+ {\r
+ newVal[i] = _newVal[i];\r
+ d_lw[i] = 0.5f*(_d_lw[i] - _d_up[i]);\r
+ interval[i] = 0.5f*(_d_lw[i] + _d_up[i]);\r
+ if( fixedRange )\r
+ val0[i] = img[L*cn+i];\r
+ }\r
+\r
+ if( cn == 1 )\r
+ {\r
+ if( fixedRange )\r
+ {\r
+ while( !mask[R + 1] && DIFF_FLT_C1( img + (R+1), val0 ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_FLT_C1( img + (L-1), val0 ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ else\r
+ {\r
+ while( !mask[R + 1] && DIFF_FLT_C1( img + (R+1), img + R ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_FLT_C1( img + (L-1), img + L ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if( fixedRange )\r
+ {\r
+ while( !mask[R + 1] && DIFF_FLT_C3( img + (R+1)*3, val0 ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_FLT_C3( img + (L-1)*3, val0 ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ else\r
+ {\r
+ while( !mask[R + 1] && DIFF_FLT_C3( img + (R+1)*3, img + R*3 ))\r
+ mask[++R] = newMaskVal;\r
+\r
+ while( !mask[L - 1] && DIFF_FLT_C3( img + (L-1)*3, img + L*3 ))\r
+ mask[--L] = newMaskVal;\r
+ }\r
+ }\r
+\r
+ XMax = R;\r
+ XMin = L;\r
+ ICV_PUSH( seed.y, L, R, R + 1, R, UP );\r
+\r
+ while( head != tail )\r
+ {\r
+ int k, YC, PL, PR, dir, curstep;\r
+ ICV_POP( YC, L, R, PL, PR, dir );\r
+\r
+ int data[][3] =\r
+ {\r
+ {-dir, L - _8_connectivity, R + _8_connectivity},\r
+ {dir, L - _8_connectivity, PL - 1},\r
+ {dir, PR + 1, R + _8_connectivity}\r
+ };\r
+\r
+ unsigned length = (unsigned)(R-L);\r
+\r
+ if( region )\r
+ {\r
+ area += (int)length + 1;\r
+\r
+ if( XMax < R ) XMax = R;\r
+ if( XMin > L ) XMin = L;\r
+ if( YMax < YC ) YMax = YC;\r
+ if( YMin > YC ) YMin = YC;\r
+ }\r
+\r
+ if( cn == 1 )\r
+ {\r
+ for( k = 0; k < 3; k++ )\r
+ {\r
+ dir = data[k][0];\r
+ curstep = dir * step;\r
+ img = pImage + (YC + dir) * step;\r
+ mask = pMask + (YC + dir) * maskStep;\r
+ int left = data[k][1];\r
+ int right = data[k][2];\r
+\r
+ if( fixedRange )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_FLT_C1( img + i, val0 ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_FLT_C1( img + j, val0 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] && DIFF_FLT_C1( img + i, val0 ))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else if( !_8_connectivity )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_FLT_C1( img + i, img - curstep + i ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_FLT_C1( img + j, img + (j+1) ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ (DIFF_FLT_C1( img + i, img + (i-1) ) ||\r
+ (DIFF_FLT_C1( img + i, img + i - curstep) && i <= R)))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ int idx;\r
+ float val[1];\r
+\r
+ if( !mask[i] &&\r
+ (((val[0] = img[i],\r
+ (unsigned)(idx = i-L-1) <= length) &&\r
+ DIFF_FLT_C1( val, img - curstep + (i-1) )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C1( val, img - curstep + i )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C1( val, img - curstep + (i+1) ))))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_FLT_C1( img + j, img + (j+1) ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ ((val[0] = img[i],\r
+ DIFF_FLT_C1( val, img + (i-1) )) ||\r
+ (((unsigned)(idx = i-L-1) <= length &&\r
+ DIFF_FLT_C1( val, img - curstep + (i-1) ))) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C1( val, img - curstep + i )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C1( val, img - curstep + (i+1) ))))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ }\r
+\r
+ img = pImage + YC * step;\r
+ if( fillImage )\r
+ for( i = L; i <= R; i++ )\r
+ img[i] = newVal[0];\r
+ else if( region )\r
+ for( i = L; i <= R; i++ )\r
+ sum[0] += img[i];\r
+ }\r
+ else\r
+ {\r
+ for( k = 0; k < 3; k++ )\r
+ {\r
+ dir = data[k][0];\r
+ curstep = dir * step;\r
+ img = pImage + (YC + dir) * step;\r
+ mask = pMask + (YC + dir) * maskStep;\r
+ int left = data[k][1];\r
+ int right = data[k][2];\r
+\r
+ if( fixedRange )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_FLT_C3( img + i*3, val0 ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_FLT_C3( img + j*3, val0 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] && DIFF_FLT_C3( img + i*3, val0 ))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else if( !_8_connectivity )\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ if( !mask[i] && DIFF_FLT_C3( img + i*3, img - curstep + i*3 ))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_FLT_C3( img + j*3, img + (j+1)*3 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ (DIFF_FLT_C3( img + i*3, img + (i-1)*3 ) ||\r
+ (DIFF_FLT_C3( img + i*3, img + i*3 - curstep) && i <= R)))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ else\r
+ for( i = left; i <= right; i++ )\r
+ {\r
+ int idx;\r
+ float val[3];\r
+\r
+ if( !mask[i] &&\r
+ (((ICV_SET_C3( val, img+i*3 ),\r
+ (unsigned)(idx = i-L-1) <= length) &&\r
+ DIFF_FLT_C3( val, img - curstep + (i-1)*3 )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C3( val, img - curstep + i*3 )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C3( val, img - curstep + (i+1)*3 ))))\r
+ {\r
+ int j = i;\r
+ mask[i] = newMaskVal;\r
+ while( !mask[--j] && DIFF_FLT_C3( img + j*3, img + (j+1)*3 ))\r
+ mask[j] = newMaskVal;\r
+\r
+ while( !mask[++i] &&\r
+ ((ICV_SET_C3( val, img + i*3 ),\r
+ DIFF_FLT_C3( val, img + (i-1)*3 )) ||\r
+ (((unsigned)(idx = i-L-1) <= length &&\r
+ DIFF_FLT_C3( val, img - curstep + (i-1)*3 ))) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C3( val, img - curstep + i*3 )) ||\r
+ ((unsigned)(++idx) <= length &&\r
+ DIFF_FLT_C3( val, img - curstep + (i+1)*3 ))))\r
+ mask[i] = newMaskVal;\r
+\r
+ ICV_PUSH( YC + dir, j+1, i-1, L, R, -dir );\r
+ }\r
+ }\r
+ }\r
+\r
+ img = pImage + YC * step;\r
+ if( fillImage )\r
+ for( i = L; i <= R; i++ )\r
+ ICV_SET_C3( img + i*3, newVal );\r
+ else if( region )\r
+ for( i = L; i <= R; i++ )\r
+ {\r
+ sum[0] += img[i*3];\r
+ sum[1] += img[i*3+1];\r
+ sum[2] += img[i*3+2];\r
+ }\r
+ }\r
+ }\r
+\r
+ if( region )\r
+ {\r
+ region->area = area;\r
+ region->rect.x = XMin;\r
+ region->rect.y = YMin;\r
+ region->rect.width = XMax - XMin + 1;\r
+ region->rect.height = YMax - YMin + 1;\r
+\r
+ if( fillImage )\r
+ region->value = cvScalar(newVal[0], newVal[1], newVal[2]);\r
+ else\r
+ {\r
+ double iarea = area ? 1./area : 0;\r
+ region->value = cvScalar(sum[0]*iarea, sum[1]*iarea, sum[2]*iarea);\r
+ }\r
+ }\r
+\r
+ return CV_NO_ERR;\r
+}\r
+\r
+\r
+/****************************************************************************************\\r
+* External Functions *\r
+\****************************************************************************************/\r
+\r
+typedef CvStatus (CV_CDECL* CvFloodFillFunc)(\r
+ void* img, int step, CvSize size, CvPoint seed, void* newval,\r
+ CvConnectedComp* comp, int flags, void* buffer, int buffer_size, int cn );\r
+\r
+typedef CvStatus (CV_CDECL* CvFloodFillGradFunc)(\r
+ void* img, int step, uchar* mask, int maskStep, CvSize size,\r
+ CvPoint seed, void* newval, void* d_lw, void* d_up, void* ccomp,\r
+ int flags, void* buffer, int buffer_size, int cn );\r
+\r
+static void icvInitFloodFill( void** ffill_tab,\r
+ void** ffillgrad_tab )\r
+{\r
+ ffill_tab[0] = (void*)icvFloodFill_8u_CnIR;\r
+ ffill_tab[1] = (void*)icvFloodFill_32f_CnIR;\r
+\r
+ ffillgrad_tab[0] = (void*)icvFloodFill_Grad_8u_CnIR;\r
+ ffillgrad_tab[1] = (void*)icvFloodFill_Grad_32f_CnIR;\r
+}\r
+\r
+\r
+CV_IMPL void\r
+cvFloodFill( CvArr* arr, CvPoint seed_point,\r
+ CvScalar newVal, CvScalar lo_diff, CvScalar up_diff,\r
+ CvConnectedComp* comp, int flags, CvArr* maskarr )\r
+{\r
+ static void* ffill_tab[4];\r
+ static void* ffillgrad_tab[4];\r
+ static int inittab = 0;\r
+\r
+ CvMat* tempMask = 0;\r
+ CvFFillSegment* buffer = 0;\r
+ CV_FUNCNAME( "cvFloodFill" );\r
+\r
+ if( comp )\r
+ memset( comp, 0, sizeof(*comp) );\r
+\r
+ __BEGIN__;\r
+\r
+ int i, type, depth, cn, is_simple, idx;\r
+ int buffer_size, connectivity = flags & 255;\r
+ double nv_buf[4] = {0,0,0,0};\r
+ union { uchar b[4]; float f[4]; } ld_buf, ud_buf;\r
+ CvMat stub, *img = (CvMat*)arr;\r
+ CvMat maskstub, *mask = (CvMat*)maskarr;\r
+ CvSize size;\r
+\r
+ if( !inittab )\r
+ {\r
+ icvInitFloodFill( ffill_tab, ffillgrad_tab );\r
+ inittab = 1;\r
+ }\r
+\r
+ CV_CALL( img = cvGetMat( img, &stub ));\r
+ type = CV_MAT_TYPE( img->type );\r
+ depth = CV_MAT_DEPTH(type);\r
+ cn = CV_MAT_CN(type);\r
+\r
+ idx = type == CV_8UC1 || type == CV_8UC3 ? 0 :\r
+ type == CV_32FC1 || type == CV_32FC3 ? 1 : -1;\r
+\r
+ if( idx < 0 )\r
+ CV_ERROR( CV_StsUnsupportedFormat, "" );\r
+\r
+ if( connectivity == 0 )\r
+ connectivity = 4;\r
+ else if( connectivity != 4 && connectivity != 8 )\r
+ CV_ERROR( CV_StsBadFlag, "Connectivity must be 4, 0(=4) or 8" );\r
+\r
+ is_simple = mask == 0 && (flags & CV_FLOODFILL_MASK_ONLY) == 0;\r
+\r
+ for( i = 0; i < cn; i++ )\r
+ {\r
+ if( lo_diff.val[i] < 0 || up_diff.val[i] < 0 )\r
+ CV_ERROR( CV_StsBadArg, "lo_diff and up_diff must be non-negative" );\r
+ is_simple &= fabs(lo_diff.val[i]) < DBL_EPSILON && fabs(up_diff.val[i]) < DBL_EPSILON;\r
+ }\r
+\r
+ size = cvGetMatSize( img );\r
+\r
+ if( (unsigned)seed_point.x >= (unsigned)size.width ||\r
+ (unsigned)seed_point.y >= (unsigned)size.height )\r
+ CV_ERROR( CV_StsOutOfRange, "Seed point is outside of image" );\r
+\r
+ cvScalarToRawData( &newVal, &nv_buf, type, 0 );\r
+ buffer_size = MAX( size.width, size.height )*2;\r
+ CV_CALL( buffer = (CvFFillSegment*)cvAlloc( buffer_size*sizeof(buffer[0])));\r
+\r
+ if( is_simple )\r
+ {\r
+ int elem_size = CV_ELEM_SIZE(type);\r
+ const uchar* seed_ptr = img->data.ptr + img->step*seed_point.y + elem_size*seed_point.x;\r
+ CvFloodFillFunc func = (CvFloodFillFunc)ffill_tab[idx];\r
+ if( !func )\r
+ CV_ERROR( CV_StsUnsupportedFormat, "" );\r
+ // check if the new value is different from the current value at the seed point.\r
+ // if they are exactly the same, use the generic version with mask to avoid infinite loops.\r
+ for( i = 0; i < elem_size; i++ )\r
+ if( seed_ptr[i] != ((uchar*)nv_buf)[i] )\r
+ break;\r
+ if( i < elem_size )\r
+ {\r
+ IPPI_CALL( func( img->data.ptr, img->step, size,\r
+ seed_point, &nv_buf, comp, flags,\r
+ buffer, buffer_size, cn ));\r
+ EXIT;\r
+ }\r
+ }\r
+\r
+ {\r
+ CvFloodFillGradFunc func = (CvFloodFillGradFunc)ffillgrad_tab[idx];\r
+ if( !func )\r
+ CV_ERROR( CV_StsUnsupportedFormat, "" );\r
+\r
+ if( !mask )\r
+ {\r
+ /* created mask will be 8-byte aligned */\r
+ tempMask = cvCreateMat( size.height + 2, (size.width + 9) & -8, CV_8UC1 );\r
+ mask = tempMask;\r
+ }\r
+ else\r
+ {\r
+ CV_CALL( mask = cvGetMat( mask, &maskstub ));\r
+ if( !CV_IS_MASK_ARR( mask ))\r
+ CV_ERROR( CV_StsBadMask, "" );\r
+\r
+ if( mask->width != size.width + 2 || mask->height != size.height + 2 )\r
+ CV_ERROR( CV_StsUnmatchedSizes, "mask must be 2 pixel wider "\r
+ "and 2 pixel taller than filled image" );\r
+ }\r
+\r
+ {\r
+ int width = tempMask ? mask->step : size.width + 2;\r
+ uchar* mask_row = mask->data.ptr + mask->step;\r
+ memset( mask_row - mask->step, 1, width );\r
+\r
+ for( i = 1; i <= size.height; i++, mask_row += mask->step )\r
+ {\r
+ if( tempMask )\r
+ memset( mask_row, 0, width );\r
+ mask_row[0] = mask_row[size.width+1] = (uchar)1;\r
+ }\r
+ memset( mask_row, 1, width );\r
+ }\r
+\r
+ if( depth == CV_8U )\r
+ for( i = 0; i < cn; i++ )\r
+ {\r
+ int t = cvFloor(lo_diff.val[i]);\r
+ ld_buf.b[i] = CV_CAST_8U(t);\r
+ t = cvFloor(up_diff.val[i]);\r
+ ud_buf.b[i] = CV_CAST_8U(t);\r
+ }\r
+ else\r
+ for( i = 0; i < cn; i++ )\r
+ {\r
+ ld_buf.f[i] = (float)lo_diff.val[i];\r
+ ud_buf.f[i] = (float)up_diff.val[i];\r
+ }\r
+\r
+ IPPI_CALL( func( img->data.ptr, img->step, mask->data.ptr, mask->step,\r
+ size, seed_point, &nv_buf, ld_buf.f, ud_buf.f,\r
+ comp, flags, buffer, buffer_size, cn ));\r
+ }\r
+\r
+ __END__;\r
+\r
+ cvFree( &buffer );\r
+ cvReleaseMat( &tempMask );\r
+}\r
+\r
+\r
+int cv::floodFill( Mat& image, Point seedPoint,\r
+ Scalar newVal, Rect* rect,\r
+ Scalar loDiff, Scalar upDiff, int flags )\r
+{\r
+ CvConnectedComp ccomp;\r
+ CvMat _image = image;\r
+ cvFloodFill(&_image, seedPoint, newVal, loDiff, upDiff, &ccomp, flags, 0);\r
+ if( rect )\r
+ *rect = ccomp.rect;\r
+ return cvRound(ccomp.area);\r
+}\r
+\r
+int cv::floodFill( Mat& image, Mat& mask,\r
+ Point seedPoint, Scalar newVal, Rect* rect, \r
+ Scalar loDiff, Scalar upDiff, int flags )\r
+{\r
+ CvConnectedComp ccomp;\r
+ CvMat _image = image, _mask = mask;\r
+ cvFloodFill(&_image, seedPoint, newVal, loDiff, upDiff, &ccomp, flags, &_mask);\r
+ if( rect )\r
+ *rect = ccomp.rect;\r
+ return cvRound(ccomp.area);\r
+}\r
+\r
+/* End of file. */\r
projects / opencv / blobdiff