mirror of
https://github.com/opencv/opencv.git
synced 2024-12-04 16:59:12 +08:00
1881 lines
56 KiB
C++
1881 lines
56 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// 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.
|
|
//
|
|
//
|
|
// Intel License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's 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.
|
|
//
|
|
// * The name of Intel Corporation may not 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 the Intel Corporation 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.
|
|
//
|
|
//M*/
|
|
#include "precomp.hpp"
|
|
|
|
typedef struct _CvRGBf
|
|
{ float blue;
|
|
float green;
|
|
float red;
|
|
}
|
|
_CvRGBf;
|
|
|
|
typedef struct _CvRect16u
|
|
{
|
|
ushort x1, y1, x2, y2;
|
|
}
|
|
_CvRect16u;
|
|
|
|
typedef struct _CvPyramid
|
|
{
|
|
float c;
|
|
struct _CvPyramid *p;
|
|
int a;
|
|
_CvRect16u rect; /* ROI for the connected component */
|
|
} _CvPyramid;
|
|
|
|
/* element of base layer */
|
|
typedef struct _CvPyramidBase
|
|
{
|
|
float c;
|
|
struct _CvPyramid *p;
|
|
}
|
|
_CvPyramidBase;
|
|
|
|
typedef struct _CvPyramidC3
|
|
{
|
|
_CvRGBf c;
|
|
struct _CvPyramidC3 *p;
|
|
int a;
|
|
_CvRect16u rect; /* ROI for the connected component */
|
|
} _CvPyramidC3;
|
|
|
|
/* element of base layer */
|
|
typedef struct _CvPyramidBaseC3
|
|
{
|
|
_CvRGBf c;
|
|
struct _CvPyramidC3 *p;
|
|
}
|
|
_CvPyramidBaseC3;
|
|
|
|
typedef struct _CvListNode
|
|
{
|
|
struct _CvListNode* next;
|
|
void* data;
|
|
}
|
|
_CvListNode;
|
|
|
|
|
|
static CvStatus icvSegmentClusterC1( CvSeq* cmp_seq, CvSeq* res_seq,
|
|
double threshold,
|
|
_CvPyramid* first_level_end,
|
|
CvSize first_level_size );
|
|
|
|
static CvStatus icvSegmentClusterC3( CvSeq* cmp_seq, CvSeq* res_seq,
|
|
double threshold,
|
|
_CvPyramidC3* first_level_end,
|
|
CvSize first_level_size );
|
|
|
|
typedef void (CV_CDECL * CvWriteNodeFunction)(void* seq,void* node);
|
|
|
|
static CvStatus icvUpdatePyrLinks_8u_C1
|
|
(int layer, void *layer_data, CvSize size, void *parent_layer,
|
|
void *_writer, float threshold, int is_last_iter, void *_stub, CvWriteNodeFunction /*func*/);
|
|
|
|
static CvStatus icvUpdatePyrLinks_8u_C3
|
|
(int layer, void *layer_data, CvSize size, void *parent_layer,
|
|
void *_writer, float threshold, int is_last_iter, void *_stub, CvWriteNodeFunction /*func*/);
|
|
|
|
static void icvMaxRoi( _CvRect16u *max_rect, _CvRect16u* cur_rect );
|
|
static void icvMaxRoi1( _CvRect16u *max_rect, int x, int y );
|
|
|
|
|
|
#define _CV_CHECK( icvFun ) \
|
|
{ \
|
|
if( icvFun != CV_OK ) \
|
|
goto M_END; \
|
|
}
|
|
|
|
|
|
#define _CV_MAX3( a, b, c) ((a)>(b) ? ((a)>(c) ? (a) : (c)) : ((b)>(c) ? (b) : (c)))
|
|
|
|
/*#define _CV_RGB_DIST(a, b) _CV_MAX3((float)fabs((a).red - (b).red), \
|
|
(float)fabs((a).green - (b).green), \
|
|
(float)fabs((a).blue - (b).blue))*/
|
|
|
|
#define _CV_NEXT_BASE_C1(p,n) (_CvPyramid*)((char*)(p) + (n)*sizeof(_CvPyramidBase))
|
|
#define _CV_NEXT_BASE_C3(p,n) (_CvPyramidC3*)((char*)(p) + (n)*sizeof(_CvPyramidBaseC3))
|
|
|
|
|
|
CV_INLINE float icvRGBDist_Max( const _CvRGBf& a, const _CvRGBf& b )
|
|
{
|
|
float tr = (float)fabs(a.red - b.red);
|
|
float tg = (float)fabs(a.green - b.green);
|
|
float tb = (float)fabs(a.blue - b.blue);
|
|
|
|
return _CV_MAX3( tr, tg, tb );
|
|
}
|
|
|
|
CV_INLINE float icvRGBDist_Sum( const _CvRGBf& a, const _CvRGBf& b )
|
|
{
|
|
float tr = (float)fabs(a.red - b.red);
|
|
float tg = (float)fabs(a.green - b.green);
|
|
float tb = (float)fabs(a.blue - b.blue);
|
|
|
|
return (tr + tg + tb);
|
|
}
|
|
|
|
#if 1
|
|
#define _CV_RGB_DIST icvRGBDist_Max
|
|
#define _CV_RGB_THRESH_SCALE 1
|
|
#else
|
|
#define _CV_RGB_DIST icvRGBDist_Sum
|
|
#define _CV_RGB_THRESH_SCALE 3
|
|
#endif
|
|
|
|
#define _CV_INV_TAB_SIZE 32
|
|
|
|
static const float icvInvTab[ /*_CV_INV_TAB_SIZE*/ ] =
|
|
{
|
|
1.00000000f, 0.50000000f, 0.33333333f, 0.25000000f, 0.20000000f, 0.16666667f,
|
|
0.14285714f, 0.12500000f, 0.11111111f, 0.10000000f, 0.09090909f, 0.08333333f,
|
|
0.07692308f, 0.07142857f, 0.06666667f, 0.06250000f, 0.05882353f, 0.05555556f,
|
|
0.05263158f, 0.05000000f, 0.04761905f, 0.04545455f, 0.04347826f, 0.04166667f,
|
|
0.04000000f, 0.03846154f, 0.03703704f, 0.03571429f, 0.03448276f, 0.03333333f,
|
|
0.03225806f, 0.03125000f
|
|
};
|
|
|
|
static void
|
|
icvWritePyrNode( void *elem, void *writer )
|
|
{
|
|
CV_WRITE_SEQ_ELEM( *(_CvListNode *) elem, *(CvSeqWriter *) writer );
|
|
}
|
|
|
|
|
|
static CvStatus
|
|
icvPyrSegmentation8uC1R( uchar * src_image, int src_step,
|
|
uchar * dst_image, int dst_step,
|
|
CvSize roi, int filter,
|
|
CvSeq ** dst_comp, CvMemStorage * storage,
|
|
int level, int threshold1, int threshold2 )
|
|
{
|
|
int i, j, l;
|
|
int step;
|
|
const int max_iter = 3; /* maximum number of iterations */
|
|
int cur_iter = 0; /* current iteration */
|
|
|
|
_CvPyramid *pyram[16]; /* pointers to the pyramid down up to level */
|
|
|
|
float *pyramida = 0;
|
|
_CvPyramid stub;
|
|
|
|
_CvPyramid *p_cur;
|
|
_CvPyramidBase *p_base;
|
|
_CvListNode cmp_node;
|
|
|
|
CvSeq *cmp_seq = 0;
|
|
CvSeq *res_seq = 0;
|
|
CvMemStorage *temp_storage = 0;
|
|
CvSize size;
|
|
CvStatus status;
|
|
CvSeqWriter writer;
|
|
|
|
int buffer_size;
|
|
char *buffer = 0;
|
|
|
|
status = CV_OK;
|
|
|
|
/* clear pointer to resultant sequence */
|
|
if( dst_comp )
|
|
*dst_comp = 0;
|
|
|
|
/* check args */
|
|
if( !src_image || !dst_image || !storage || !dst_comp )
|
|
return CV_NULLPTR_ERR;
|
|
if( roi.width <= 0 || roi.height <= 0 || src_step < roi.width || dst_step < roi.width )
|
|
return CV_BADSIZE_ERR;
|
|
if( filter != CV_GAUSSIAN_5x5 )
|
|
return CV_BADRANGE_ERR;
|
|
if( threshold1 < 0 || threshold2 < 0 )
|
|
return CV_BADRANGE_ERR;
|
|
if( level <= 0 )
|
|
return CV_BADRANGE_ERR;
|
|
|
|
if( ((roi.width | roi.height) & ((1 << level) - 1)) != 0 )
|
|
return CV_BADCOEF_ERR;
|
|
|
|
temp_storage = cvCreateChildMemStorage( storage );
|
|
|
|
/* sequence for temporary components */
|
|
cmp_seq = cvCreateSeq( 0, sizeof( CvSeq ), sizeof( _CvListNode ), temp_storage );
|
|
assert( cmp_seq != 0 );
|
|
|
|
res_seq = cvCreateSeq( CV_SEQ_CONNECTED_COMP, sizeof( CvSeq ),
|
|
sizeof( CvConnectedComp ), storage );
|
|
assert( res_seq != 0 );
|
|
|
|
/* calculate buffer size */
|
|
buffer_size = roi.width * roi.height * (sizeof( float ) + sizeof( _CvPyramidBase ));
|
|
|
|
for( l = 1; l <= level; l++ )
|
|
buffer_size += ((roi.width >> l) + 1) * ((roi.height >> l) + 1) * sizeof(_CvPyramid);
|
|
|
|
/* allocate buffer */
|
|
buffer = (char *) cvAlloc( buffer_size );
|
|
if( !buffer )
|
|
{
|
|
status = CV_OUTOFMEM_ERR;
|
|
goto M_END;
|
|
}
|
|
|
|
pyramida = (float *) buffer;
|
|
|
|
/* initialization pyramid-linking properties down up to level */
|
|
step = roi.width * sizeof( float );
|
|
|
|
{
|
|
CvMat _src;
|
|
CvMat _pyramida;
|
|
cvInitMatHeader( &_src, roi.height, roi.width, CV_8UC1, src_image, src_step );
|
|
cvInitMatHeader( &_pyramida, roi.height, roi.width, CV_32FC1, pyramida, step );
|
|
cvConvert( &_src, &_pyramida );
|
|
/*_CV_CHECK( icvCvtTo_32f_C1R( src_image, src_step, pyramida, step, roi, CV_8UC1 ));*/
|
|
}
|
|
p_base = (_CvPyramidBase *) (buffer + step * roi.height);
|
|
pyram[0] = (_CvPyramid *) p_base;
|
|
|
|
/* fill base level of pyramid */
|
|
for( i = 0; i < roi.height; i++ )
|
|
{
|
|
for( j = 0; j < roi.width; j++, p_base++ )
|
|
{
|
|
p_base->c = pyramida[i * roi.width + j];
|
|
p_base->p = &stub;
|
|
}
|
|
}
|
|
|
|
p_cur = (_CvPyramid *) p_base;
|
|
size = roi;
|
|
|
|
/* calculate initial pyramid */
|
|
for( l = 1; l <= level; l++ )
|
|
{
|
|
CvSize dst_size(size.width/2+1, size.height/2+1);
|
|
CvMat prev_level = cvMat( size.height, size.width, CV_32FC1 );
|
|
CvMat next_level = cvMat( dst_size.height, dst_size.width, CV_32FC1 );
|
|
|
|
cvSetData( &prev_level, pyramida, step );
|
|
cvSetData( &next_level, pyramida, step );
|
|
cvPyrDown( &prev_level, &next_level );
|
|
|
|
//_CV_CHECK( icvPyrDown_Gauss5x5_32f_C1R( pyramida, step, pyramida, step, size, buff ));
|
|
//_CV_CHECK( icvPyrDownBorder_32f_CnR( pyramida, step, size, pyramida, step, dst_size, 1 ));
|
|
pyram[l] = p_cur;
|
|
|
|
size.width = dst_size.width - 1;
|
|
size.height = dst_size.height - 1;
|
|
|
|
/* fill layer #l */
|
|
for( i = 0; i <= size.height; i++ )
|
|
{
|
|
for( j = 0; j <= size.width; j++, p_cur++ )
|
|
{
|
|
p_cur->c = pyramida[i * roi.width + j];
|
|
p_cur->p = &stub;
|
|
p_cur->a = 0;
|
|
p_cur->rect.x2 = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
cvStartAppendToSeq( cmp_seq, &writer );
|
|
|
|
/* do several iterations to determine son-father links */
|
|
for( cur_iter = 0; cur_iter < max_iter; cur_iter++ )
|
|
{
|
|
int is_last_iter = cur_iter == max_iter - 1;
|
|
|
|
size = roi;
|
|
|
|
/* build son-father links down up to level */
|
|
for( l = 0; l < level; l++ )
|
|
{
|
|
icvUpdatePyrLinks_8u_C1( l, pyram[l], size, pyram[l + 1], &writer,
|
|
(float) threshold1, is_last_iter, &stub,
|
|
icvWritePyrNode );
|
|
|
|
/* clear last border row */
|
|
if( l > 0 )
|
|
{
|
|
p_cur = pyram[l] + (size.width + 1) * size.height;
|
|
for( j = 0; j <= size.width; j++ )
|
|
p_cur[j].c = 0;
|
|
}
|
|
|
|
size.width >>= 1;
|
|
size.height >>= 1;
|
|
}
|
|
|
|
/* clear the old c value for the last level */
|
|
p_cur = pyram[level];
|
|
for( i = 0; i <= size.height; i++, p_cur += size.width + 1 )
|
|
for( j = 0; j <= size.width; j++ )
|
|
p_cur[j].c = 0;
|
|
|
|
size = roi;
|
|
step = roi.width;
|
|
|
|
/* calculate average c value for the 0 < l <=level */
|
|
for( l = 0; l < level; l++, step = (step >> 1) + 1 )
|
|
{
|
|
_CvPyramid *p_prev, *p_row_prev;
|
|
|
|
stub.c = 0;
|
|
|
|
/* calculate average c value for the next level */
|
|
if( l == 0 )
|
|
{
|
|
p_base = (_CvPyramidBase *) pyram[0];
|
|
for( i = 0; i < roi.height; i++, p_base += size.width )
|
|
{
|
|
for( j = 0; j < size.width; j += 2 )
|
|
{
|
|
_CvPyramid *p1 = p_base[j].p;
|
|
_CvPyramid *p2 = p_base[j + 1].p;
|
|
|
|
p1->c += p_base[j].c;
|
|
p2->c += p_base[j + 1].c;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_cur = pyram[l];
|
|
for( i = 0; i < size.height; i++, p_cur += size.width + 1 )
|
|
{
|
|
for( j = 0; j < size.width; j += 2 )
|
|
{
|
|
_CvPyramid *p1 = p_cur[j].p;
|
|
_CvPyramid *p2 = p_cur[j + 1].p;
|
|
|
|
float t0 = (float) p_cur[j].a * p_cur[j].c;
|
|
float t1 = (float) p_cur[j + 1].a * p_cur[j + 1].c;
|
|
|
|
p1->c += t0;
|
|
p2->c += t1;
|
|
|
|
if( !is_last_iter )
|
|
p_cur[j].a = p_cur[j + 1].a = 0;
|
|
}
|
|
if( !is_last_iter )
|
|
p_cur[size.width].a = 0;
|
|
}
|
|
if( !is_last_iter )
|
|
{
|
|
for( j = 0; j <= size.width; j++ )
|
|
{
|
|
p_cur[j].a = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* assign random values of the next level null c */
|
|
p_cur = pyram[l + 1];
|
|
p_row_prev = p_prev = pyram[l];
|
|
|
|
size.width >>= 1;
|
|
size.height >>= 1;
|
|
|
|
for( i = 0; i <= size.height; i++, p_cur += size.width + 1 )
|
|
{
|
|
if( i < size.height || !is_last_iter )
|
|
{
|
|
for( j = 0; j < size.width; j++ )
|
|
{
|
|
int a = p_cur[j].a;
|
|
|
|
if( a != 0 )
|
|
{
|
|
if( a <= _CV_INV_TAB_SIZE )
|
|
{
|
|
p_cur[j].c *= icvInvTab[a - 1];
|
|
}
|
|
else
|
|
{
|
|
p_cur[j].c /= a;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_cur[j].c = p_prev->c;
|
|
}
|
|
|
|
if( l == 0 )
|
|
p_prev = _CV_NEXT_BASE_C1(p_prev,2);
|
|
else
|
|
p_prev += 2;
|
|
}
|
|
|
|
if( p_cur[size.width].a == 0 )
|
|
{
|
|
p_cur[size.width].c = p_prev[(l != 0) - 1].c;
|
|
}
|
|
else
|
|
{
|
|
p_cur[size.width].c /= p_cur[size.width].a;
|
|
if( is_last_iter )
|
|
{
|
|
cmp_node.data = p_cur + size.width;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( j = 0; j <= size.width; j++ )
|
|
{
|
|
int a = p_cur[j].a;
|
|
|
|
if( a != 0 )
|
|
{
|
|
if( a <= _CV_INV_TAB_SIZE )
|
|
{
|
|
p_cur[j].c *= icvInvTab[a - 1];
|
|
}
|
|
else
|
|
{
|
|
p_cur[j].c /= a;
|
|
}
|
|
|
|
cmp_node.data = p_cur + j;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
else
|
|
{
|
|
p_cur[j].c = p_prev->c;
|
|
}
|
|
|
|
if( l == 0 )
|
|
{
|
|
p_prev = _CV_NEXT_BASE_C1(p_prev, (j * 2 < step - 2 ? 2 : 1));
|
|
}
|
|
else
|
|
{
|
|
p_prev++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( l + 1 == level && !is_last_iter )
|
|
for( j = 0; j <= size.width; j++ )
|
|
p_cur[j].a = 0;
|
|
|
|
if( !(i & 1) )
|
|
{
|
|
p_prev = p_row_prev;
|
|
}
|
|
else
|
|
{
|
|
p_prev = (_CvPyramid*)((char*)p_row_prev + step *
|
|
(l == 0 ? sizeof(_CvPyramidBase) : sizeof(_CvPyramid)));
|
|
}
|
|
}
|
|
}
|
|
} /* end of the iteration process */
|
|
|
|
/* construct a connected components */
|
|
size.width = roi.width >> level;
|
|
size.height = roi.height >> level;
|
|
|
|
p_cur = pyram[level];
|
|
|
|
for( i = 0; i < size.height; i++, p_cur += size.width + 1 )
|
|
{
|
|
for( j = 0; j < size.width; j++ )
|
|
{
|
|
if( p_cur[j].a != 0 )
|
|
{
|
|
cmp_node.data = p_cur + j;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
}
|
|
}
|
|
|
|
cvEndWriteSeq( &writer );
|
|
|
|
/* clusterization segmented components and construction
|
|
output connected components */
|
|
icvSegmentClusterC1( cmp_seq, res_seq, threshold2, pyram[1], roi );
|
|
|
|
/* convert (inplace) resultant segment values to int (top level) */
|
|
|
|
/* propagate segment values top down */
|
|
for( l = level - 1; l >= 0; l-- )
|
|
{
|
|
p_cur = pyram[l];
|
|
|
|
size.width <<= 1;
|
|
size.height <<= 1;
|
|
|
|
if( l == 0 )
|
|
{
|
|
size.width--;
|
|
size.height--;
|
|
}
|
|
|
|
for( i = 0; i <= size.height; i++ )
|
|
{
|
|
for( j = 0; j <= size.width; j++ )
|
|
{
|
|
_CvPyramid *p = p_cur->p;
|
|
|
|
assert( p != 0 );
|
|
if( p != &stub )
|
|
p_cur->c = p->c;
|
|
|
|
if( l == 0 )
|
|
{
|
|
Cv32suf _c;
|
|
/* copy the segmented values to destination image */
|
|
_c.f = p_cur->c; dst_image[j] = (uchar)_c.i;
|
|
p_cur = _CV_NEXT_BASE_C1(p_cur, 1);
|
|
}
|
|
else
|
|
{
|
|
p_cur++;
|
|
}
|
|
}
|
|
if( l == 0 )
|
|
dst_image += dst_step;
|
|
}
|
|
}
|
|
M_END:
|
|
|
|
cvFree( &buffer );
|
|
cvReleaseMemStorage( &temp_storage );
|
|
|
|
if( status == CV_OK )
|
|
*dst_comp = res_seq;
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************************\
|
|
color!!! image segmentation by pyramid-linking
|
|
\****************************************************************************************/
|
|
static CvStatus
|
|
icvPyrSegmentation8uC3R( uchar * src_image, int src_step,
|
|
uchar * dst_image, int dst_step,
|
|
CvSize roi, int filter,
|
|
CvSeq ** dst_comp, CvMemStorage * storage,
|
|
int level, int threshold1, int threshold2 )
|
|
{
|
|
int i, j, l;
|
|
|
|
int step;
|
|
const int max_iter = 3; /* maximum number of iterations */
|
|
int cur_iter = 0; /* current iteration */
|
|
|
|
_CvPyramidC3 *pyram[16]; /* pointers to the pyramid down up to level */
|
|
|
|
float *pyramida = 0;
|
|
_CvPyramidC3 stub;
|
|
|
|
_CvPyramidC3 *p_cur;
|
|
_CvPyramidBaseC3 *p_base;
|
|
_CvListNode cmp_node;
|
|
|
|
CvSeq *cmp_seq = 0;
|
|
CvSeq *res_seq = 0;
|
|
CvMemStorage *temp_storage = 0;
|
|
CvSize size;
|
|
CvStatus status;
|
|
CvSeqWriter writer;
|
|
|
|
int buffer_size;
|
|
char *buffer = 0;
|
|
|
|
status = CV_OK;
|
|
|
|
threshold1 *= _CV_RGB_THRESH_SCALE;
|
|
threshold2 *= _CV_RGB_THRESH_SCALE;
|
|
|
|
/* clear pointer to resultant sequence */
|
|
if( dst_comp )
|
|
*dst_comp = 0;
|
|
|
|
/* check args */
|
|
if( !src_image || !dst_image || !storage || !dst_comp )
|
|
return CV_NULLPTR_ERR;
|
|
if( roi.width <= 0 || roi.height <= 0 ||
|
|
src_step < roi.width * 3 || dst_step < roi.width * 3 ) return CV_BADSIZE_ERR;
|
|
if( filter != CV_GAUSSIAN_5x5 )
|
|
return CV_BADRANGE_ERR;
|
|
if( threshold1 < 0 || threshold2 < 0 )
|
|
return CV_BADRANGE_ERR;
|
|
if( level <= 0 )
|
|
return CV_BADRANGE_ERR;
|
|
|
|
if( ((roi.width | roi.height) & ((1 << level) - 1)) != 0 )
|
|
return CV_BADCOEF_ERR;
|
|
|
|
temp_storage = cvCreateChildMemStorage( storage );
|
|
|
|
/* sequence for temporary components */
|
|
cmp_seq = cvCreateSeq( 0, sizeof( CvSeq ), sizeof( _CvListNode ), temp_storage );
|
|
assert( cmp_seq != 0 );
|
|
|
|
res_seq = cvCreateSeq( CV_SEQ_CONNECTED_COMP, sizeof( CvSeq ),
|
|
sizeof( CvConnectedComp ), storage );
|
|
assert( res_seq != 0 );
|
|
|
|
/* calculate buffer size */
|
|
buffer_size = roi.width * roi.height * (sizeof( _CvRGBf ) + sizeof( _CvPyramidBaseC3 ));
|
|
|
|
for( l = 1; l <= level; l++ )
|
|
buffer_size += ((roi.width >> l) + 1) * ((roi.height >> l) + 1) * sizeof(_CvPyramidC3);
|
|
|
|
/* allocate buffer */
|
|
buffer = (char *) cvAlloc( buffer_size );
|
|
if( !buffer )
|
|
{
|
|
status = CV_OUTOFMEM_ERR;
|
|
goto M_END;
|
|
}
|
|
|
|
pyramida = (float *) buffer;
|
|
|
|
/* initialization pyramid-linking properties down up to level */
|
|
step = roi.width * sizeof( _CvRGBf );
|
|
|
|
{
|
|
CvMat _src;
|
|
CvMat _pyramida;
|
|
cvInitMatHeader( &_src, roi.height, roi.width, CV_8UC3, src_image, src_step );
|
|
cvInitMatHeader( &_pyramida, roi.height, roi.width, CV_32FC3, pyramida, step );
|
|
cvConvert( &_src, &_pyramida );
|
|
/*_CV_CHECK( icvCvtTo_32f_C1R( src_image, src_step, pyramida, step,
|
|
cvSize( roi.width * 3, roi.height ), CV_8UC1 ));*/
|
|
}
|
|
|
|
p_base = (_CvPyramidBaseC3 *) (buffer + step * roi.height);
|
|
pyram[0] = (_CvPyramidC3 *) p_base;
|
|
|
|
/* fill base level of pyramid */
|
|
for( i = 0; i < roi.height; i++ )
|
|
{
|
|
for( j = 0; j < roi.width; j++, p_base++ )
|
|
{
|
|
p_base->c = ((_CvRGBf *) pyramida)[i * roi.width + j];
|
|
p_base->p = &stub;
|
|
}
|
|
}
|
|
|
|
p_cur = (_CvPyramidC3 *) p_base;
|
|
size = roi;
|
|
|
|
/* calculate initial pyramid */
|
|
for( l = 1; l <= level; l++ )
|
|
{
|
|
CvSize dst_size(size.width/2 + 1, size.height/2 + 1);
|
|
CvMat prev_level = cvMat( size.height, size.width, CV_32FC3 );
|
|
CvMat next_level = cvMat( dst_size.height, dst_size.width, CV_32FC3 );
|
|
|
|
cvSetData( &prev_level, pyramida, step );
|
|
cvSetData( &next_level, pyramida, step );
|
|
cvPyrDown( &prev_level, &next_level );
|
|
|
|
//_CV_CHECK( icvPyrDown_Gauss5x5_32f_C3R( pyramida, step, pyramida, step, size, buff ));
|
|
//_CV_CHECK( icvPyrDownBorder_32f_CnR( pyramida, step, size, pyramida, step, dst_size, 3 ));
|
|
pyram[l] = p_cur;
|
|
|
|
size.width = dst_size.width - 1;
|
|
size.height = dst_size.height - 1;
|
|
|
|
/* fill layer #l */
|
|
for( i = 0; i <= size.height; i++ )
|
|
{
|
|
assert( (char*)p_cur - buffer < buffer_size );
|
|
for( j = 0; j <= size.width; j++, p_cur++ )
|
|
{
|
|
p_cur->c = ((_CvRGBf *) pyramida)[i * roi.width + j];
|
|
p_cur->p = &stub;
|
|
p_cur->a = 0;
|
|
p_cur->rect.x2 = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
cvStartAppendToSeq( cmp_seq, &writer );
|
|
|
|
/* do several iterations to determine son-father links */
|
|
for( cur_iter = 0; cur_iter < max_iter; cur_iter++ )
|
|
{
|
|
int is_last_iter = cur_iter == max_iter - 1;
|
|
|
|
size = roi;
|
|
|
|
/* build son-father links down up to level */
|
|
for( l = 0; l < level; l++ )
|
|
{
|
|
icvUpdatePyrLinks_8u_C3( l, pyram[l], size, pyram[l + 1], &writer,
|
|
(float) threshold1, is_last_iter, &stub,
|
|
icvWritePyrNode );
|
|
|
|
/* clear last border row */
|
|
if( l > 0 )
|
|
{
|
|
p_cur = pyram[l] + (size.width + 1) * size.height;
|
|
for( j = 0; j <= size.width; j++ )
|
|
p_cur[j].c.blue = p_cur[j].c.green = p_cur[j].c.red = 0;
|
|
}
|
|
|
|
size.width >>= 1;
|
|
size.height >>= 1;
|
|
}
|
|
|
|
/* clear the old c value for the last level */
|
|
p_cur = pyram[level];
|
|
for( i = 0; i <= size.height; i++, p_cur += size.width + 1 )
|
|
for( j = 0; j <= size.width; j++ )
|
|
p_cur[j].c.blue = p_cur[j].c.green = p_cur[j].c.red = 0;
|
|
|
|
size = roi;
|
|
step = roi.width;
|
|
|
|
/* calculate average c value for the 0 < l <=level */
|
|
for( l = 0; l < level; l++, step = (step >> 1) + 1 )
|
|
{
|
|
_CvPyramidC3 *p_prev, *p_row_prev;
|
|
|
|
stub.c.blue = stub.c.green = stub.c.red = 0;
|
|
|
|
/* calculate average c value for the next level */
|
|
if( l == 0 )
|
|
{
|
|
p_base = (_CvPyramidBaseC3 *) pyram[0];
|
|
for( i = 0; i < roi.height; i++, p_base += size.width )
|
|
{
|
|
for( j = 0; j < size.width; j++ )
|
|
{
|
|
_CvPyramidC3 *p = p_base[j].p;
|
|
|
|
p->c.blue += p_base[j].c.blue;
|
|
p->c.green += p_base[j].c.green;
|
|
p->c.red += p_base[j].c.red;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_cur = pyram[l];
|
|
for( i = 0; i < size.height; i++, p_cur += size.width + 1 )
|
|
{
|
|
for( j = 0; j < size.width; j++ )
|
|
{
|
|
_CvPyramidC3 *p = p_cur[j].p;
|
|
float a = (float) p_cur[j].a;
|
|
|
|
p->c.blue += a * p_cur[j].c.blue;
|
|
p->c.green += a * p_cur[j].c.green;
|
|
p->c.red += a * p_cur[j].c.red;
|
|
|
|
if( !is_last_iter )
|
|
p_cur[j].a = 0;
|
|
}
|
|
if( !is_last_iter )
|
|
p_cur[size.width].a = 0;
|
|
}
|
|
if( !is_last_iter )
|
|
{
|
|
for( j = 0; j <= size.width; j++ )
|
|
{
|
|
p_cur[j].a = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* assign random values of the next level null c */
|
|
p_cur = pyram[l + 1];
|
|
p_row_prev = p_prev = pyram[l];
|
|
|
|
size.width >>= 1;
|
|
size.height >>= 1;
|
|
|
|
for( i = 0; i <= size.height; i++, p_cur += size.width + 1 )
|
|
{
|
|
if( i < size.height || !is_last_iter )
|
|
{
|
|
for( j = 0; j < size.width; j++ )
|
|
{
|
|
int a = p_cur[j].a;
|
|
|
|
if( a != 0 )
|
|
{
|
|
float inv_a;
|
|
|
|
if( a <= _CV_INV_TAB_SIZE )
|
|
{
|
|
inv_a = icvInvTab[a - 1];
|
|
}
|
|
else
|
|
{
|
|
inv_a = 1.f / a;
|
|
}
|
|
p_cur[j].c.blue *= inv_a;
|
|
p_cur[j].c.green *= inv_a;
|
|
p_cur[j].c.red *= inv_a;
|
|
}
|
|
else
|
|
{
|
|
p_cur[j].c = p_prev->c;
|
|
}
|
|
|
|
if( l == 0 )
|
|
p_prev = _CV_NEXT_BASE_C3( p_prev, 2 );
|
|
else
|
|
p_prev += 2;
|
|
}
|
|
|
|
if( p_cur[size.width].a == 0 )
|
|
{
|
|
p_cur[size.width].c = p_prev[(l != 0) - 1].c;
|
|
}
|
|
else
|
|
{
|
|
p_cur[size.width].c.blue /= p_cur[size.width].a;
|
|
p_cur[size.width].c.green /= p_cur[size.width].a;
|
|
p_cur[size.width].c.red /= p_cur[size.width].a;
|
|
if( is_last_iter )
|
|
{
|
|
cmp_node.data = p_cur + size.width;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( j = 0; j <= size.width; j++ )
|
|
{
|
|
int a = p_cur[j].a;
|
|
|
|
if( a != 0 )
|
|
{
|
|
float inv_a;
|
|
|
|
if( a <= _CV_INV_TAB_SIZE )
|
|
{
|
|
inv_a = icvInvTab[a - 1];
|
|
}
|
|
else
|
|
{
|
|
inv_a = 1.f / a;
|
|
}
|
|
p_cur[j].c.blue *= inv_a;
|
|
p_cur[j].c.green *= inv_a;
|
|
p_cur[j].c.red *= inv_a;
|
|
|
|
cmp_node.data = p_cur + j;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
else
|
|
{
|
|
p_cur[j].c = p_prev->c;
|
|
}
|
|
|
|
if( l == 0 )
|
|
{
|
|
p_prev = _CV_NEXT_BASE_C3( p_prev, (j * 2 < step - 2 ? 2 : 1));
|
|
}
|
|
else
|
|
{
|
|
p_prev++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( l + 1 == level && !is_last_iter )
|
|
for( j = 0; j <= size.width; j++ )
|
|
p_cur[j].a = 0;
|
|
|
|
if( !(i & 1) )
|
|
{
|
|
p_prev = p_row_prev;
|
|
}
|
|
else
|
|
{
|
|
p_prev = (_CvPyramidC3*)((char*)p_row_prev + step *
|
|
(l == 0 ? sizeof( _CvPyramidBaseC3 ) : sizeof( _CvPyramidC3 )));
|
|
}
|
|
}
|
|
}
|
|
} /* end of the iteration process */
|
|
|
|
/* construct a connected components */
|
|
size.width = roi.width >> level;
|
|
size.height = roi.height >> level;
|
|
|
|
p_cur = pyram[level];
|
|
|
|
for( i = 0; i < size.height; i++, p_cur += size.width + 1 )
|
|
{
|
|
for( j = 0; j < size.width; j++ )
|
|
{
|
|
if( p_cur[j].a != 0 )
|
|
{
|
|
cmp_node.data = p_cur + j;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
}
|
|
}
|
|
|
|
cvEndWriteSeq( &writer );
|
|
|
|
/* clusterization segmented components and construction
|
|
output connected components */
|
|
icvSegmentClusterC3( cmp_seq, res_seq, threshold2, pyram[1], roi );
|
|
|
|
/* convert (inplace) resultant segment values to int (top level) */
|
|
|
|
/* propagate segment values top down */
|
|
for( l = level - 1; l >= 0; l-- )
|
|
{
|
|
p_cur = pyram[l];
|
|
|
|
size.width <<= 1;
|
|
size.height <<= 1;
|
|
|
|
if( l == 0 )
|
|
{
|
|
size.width--;
|
|
size.height--;
|
|
}
|
|
|
|
for( i = 0; i <= size.height; i++ )
|
|
{
|
|
for( j = 0; j <= size.width; j++ )
|
|
{
|
|
_CvPyramidC3 *p = p_cur->p;
|
|
|
|
assert( p != 0 );
|
|
if( p != &stub )
|
|
{
|
|
p_cur->c = p->c;
|
|
}
|
|
|
|
if( l == 0 )
|
|
{
|
|
Cv32suf _c;
|
|
/* copy the segmented values to destination image */
|
|
_c.f = p_cur->c.blue; dst_image[j*3] = (uchar)_c.i;
|
|
_c.f = p_cur->c.green; dst_image[j*3+1] = (uchar)_c.i;
|
|
_c.f = p_cur->c.red; dst_image[j*3+2] = (uchar)_c.i;
|
|
p_cur = _CV_NEXT_BASE_C3(p_cur,1);
|
|
}
|
|
else
|
|
{
|
|
p_cur++;
|
|
}
|
|
}
|
|
if( l == 0 )
|
|
dst_image += dst_step;
|
|
}
|
|
}
|
|
|
|
M_END:
|
|
|
|
cvFree( &buffer );
|
|
cvReleaseMemStorage( &temp_storage );
|
|
|
|
if( status == CV_OK )
|
|
*dst_comp = res_seq;
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
static CvStatus icvUpdatePyrLinks_8u_C1
|
|
(int layer, void *layer_data, CvSize size, void *parent_layer,
|
|
void *_writer, float threshold, int is_last_iter, void *_stub, CvWriteNodeFunction /*func*/)
|
|
{
|
|
int i, j;
|
|
_CvListNode cmp_node;
|
|
|
|
_CvPyramid *stub = (_CvPyramid *) _stub;
|
|
_CvPyramid *p_cur = (_CvPyramid *) layer_data;
|
|
_CvPyramid *p_next1 = (_CvPyramid *) parent_layer;
|
|
_CvPyramid *p_next3 = p_next1 + (size.width >> 1) + 1;
|
|
|
|
CvSeqWriter & writer = *(CvSeqWriter *) _writer;
|
|
|
|
for( i = 0; i < size.height; i++ )
|
|
{
|
|
for( j = 0; j < size.width; j += 2 )
|
|
{
|
|
float c0, c1, c2, c3, c4;
|
|
_CvPyramid *p;
|
|
|
|
/* son-father threshold linking for the current node establish */
|
|
c0 = p_cur->c;
|
|
|
|
/* find pointer for the first pixel */
|
|
c1 = (float) fabs( c0 - p_next1[0].c );
|
|
c2 = (float) fabs( c0 - p_next1[1].c );
|
|
c3 = (float) fabs( c0 - p_next3[0].c );
|
|
c4 = (float) fabs( c0 - p_next3[1].c );
|
|
|
|
p = p_next1;
|
|
|
|
if( c1 > c2 )
|
|
{
|
|
p = p_next1 + 1;
|
|
c1 = c2;
|
|
}
|
|
if( c1 > c3 )
|
|
{
|
|
p = p_next3;
|
|
c1 = c3;
|
|
}
|
|
if( c1 > c4 )
|
|
{
|
|
p = p_next3 + 1;
|
|
c1 = c4;
|
|
}
|
|
|
|
if( c1 <= threshold )
|
|
{
|
|
p_cur->p = p;
|
|
|
|
if( layer == 0 )
|
|
{
|
|
p->a++;
|
|
p_cur = (_CvPyramid*)((char*)p_cur + sizeof(_CvPyramidBase));
|
|
if( is_last_iter )
|
|
icvMaxRoi1( &(p->rect), j, i );
|
|
}
|
|
else
|
|
{
|
|
int a = p_cur->a;
|
|
|
|
p->a += a;
|
|
p_cur->c = 0;
|
|
p_cur++;
|
|
if( is_last_iter && a != 0 )
|
|
icvMaxRoi( &(p->rect), &(p_cur[-1].rect) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_cur->p = stub;
|
|
if( is_last_iter )
|
|
{
|
|
cmp_node.data = p_cur;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
if( layer == 0 )
|
|
{
|
|
p_cur = _CV_NEXT_BASE_C1(p_cur,1);
|
|
}
|
|
else
|
|
{
|
|
p_cur->c = 0;
|
|
p_cur++;
|
|
}
|
|
}
|
|
|
|
/* find pointer for the second pixel */
|
|
c0 = p_cur->c;
|
|
|
|
c1 = (float) fabs( c0 - p_next1[0].c );
|
|
c2 = (float) fabs( c0 - p_next1[1].c );
|
|
c3 = (float) fabs( c0 - p_next3[0].c );
|
|
c4 = (float) fabs( c0 - p_next3[1].c );
|
|
|
|
p = p_next1;
|
|
p_next1++;
|
|
|
|
if( c1 > c2 )
|
|
{
|
|
p = p_next1;
|
|
c1 = c2;
|
|
}
|
|
if( c1 > c3 )
|
|
{
|
|
p = p_next3;
|
|
c1 = c3;
|
|
}
|
|
|
|
p_next3++;
|
|
if( c1 > c4 )
|
|
{
|
|
p = p_next3;
|
|
c1 = c4;
|
|
}
|
|
|
|
if( c1 <= threshold )
|
|
{
|
|
p_cur->p = p;
|
|
|
|
if( layer == 0 )
|
|
{
|
|
p->a++;
|
|
p_cur = _CV_NEXT_BASE_C1(p_cur,1);
|
|
if( is_last_iter )
|
|
icvMaxRoi1( &(p->rect), j + 1, i );
|
|
}
|
|
else
|
|
{
|
|
int a = p_cur->a;
|
|
|
|
p->a += a;
|
|
p_cur->c = 0;
|
|
p_cur++;
|
|
if( is_last_iter && a != 0 )
|
|
icvMaxRoi( &(p->rect), &(p_cur[-1].rect) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_cur->p = stub;
|
|
if( is_last_iter )
|
|
{
|
|
cmp_node.data = p_cur;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
if( layer == 0 )
|
|
{
|
|
p_cur = _CV_NEXT_BASE_C1(p_cur,1);
|
|
}
|
|
else
|
|
{
|
|
p_cur->c = 0;
|
|
p_cur++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* clear c's */
|
|
if( layer > 0 )
|
|
{
|
|
p_cur->c = 0;
|
|
p_cur++;
|
|
}
|
|
|
|
if( !(i & 1) )
|
|
{
|
|
p_next1 -= size.width >> 1;
|
|
p_next3 -= size.width >> 1;
|
|
}
|
|
else
|
|
{
|
|
p_next1++;
|
|
p_next3++;
|
|
}
|
|
}
|
|
|
|
return CV_OK;
|
|
}
|
|
|
|
|
|
static CvStatus icvUpdatePyrLinks_8u_C3
|
|
(int layer, void *layer_data, CvSize size, void *parent_layer,
|
|
void *_writer, float threshold, int is_last_iter, void *_stub, CvWriteNodeFunction /*func*/)
|
|
{
|
|
int i, j;
|
|
_CvListNode cmp_node;
|
|
|
|
_CvPyramidC3 *stub = (_CvPyramidC3 *) _stub;
|
|
_CvPyramidC3 *p_cur = (_CvPyramidC3 *) layer_data;
|
|
_CvPyramidC3 *p_next1 = (_CvPyramidC3 *) parent_layer;
|
|
_CvPyramidC3 *p_next3 = p_next1 + (size.width >> 1) + 1;
|
|
|
|
CvSeqWriter & writer = *(CvSeqWriter *) _writer;
|
|
|
|
for( i = 0; i < size.height; i++ )
|
|
{
|
|
for( j = 0; j < size.width; j += 2 )
|
|
{
|
|
float c1, c2, c3, c4;
|
|
_CvPyramidC3 *p;
|
|
|
|
/* find pointer for the first pixel */
|
|
c1 = _CV_RGB_DIST( p_cur->c, p_next1[0].c );
|
|
c2 = _CV_RGB_DIST( p_cur->c, p_next1[1].c );
|
|
c3 = _CV_RGB_DIST( p_cur->c, p_next3[0].c );
|
|
c4 = _CV_RGB_DIST( p_cur->c, p_next3[1].c );
|
|
|
|
p = p_next1;
|
|
|
|
if( c1 > c2 )
|
|
{
|
|
p = p_next1 + 1;
|
|
c1 = c2;
|
|
}
|
|
if( c1 > c3 )
|
|
{
|
|
p = p_next3;
|
|
c1 = c3;
|
|
}
|
|
if( c1 > c4 )
|
|
{
|
|
p = p_next3 + 1;
|
|
c1 = c4;
|
|
}
|
|
|
|
if( c1 < threshold )
|
|
{
|
|
p_cur->p = p;
|
|
|
|
if( layer == 0 )
|
|
{
|
|
p->a++;
|
|
p_cur = _CV_NEXT_BASE_C3(p_cur,1);
|
|
if( is_last_iter )
|
|
icvMaxRoi1( &(p->rect), j, i );
|
|
}
|
|
else
|
|
{
|
|
int a = p_cur->a;
|
|
|
|
p->a += a;
|
|
p_cur->c.blue = p_cur->c.green = p_cur->c.red = 0;
|
|
p_cur++;
|
|
if( is_last_iter && a != 0 )
|
|
icvMaxRoi( &(p->rect), &(p_cur[-1].rect) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_cur->p = stub;
|
|
if( is_last_iter /* && ( == 0 || p_cur->a != 0) */ )
|
|
{
|
|
cmp_node.data = p_cur;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
|
|
if( layer == 0 )
|
|
{
|
|
p_cur = _CV_NEXT_BASE_C3(p_cur,1);
|
|
}
|
|
else
|
|
{
|
|
p_cur->c.blue = p_cur->c.green = p_cur->c.red = 0;
|
|
p_cur++;
|
|
}
|
|
}
|
|
|
|
/* find pointer for the second pixel */
|
|
c1 = _CV_RGB_DIST( p_cur->c, p_next1[0].c );
|
|
c2 = _CV_RGB_DIST( p_cur->c, p_next1[1].c );
|
|
c3 = _CV_RGB_DIST( p_cur->c, p_next3[0].c );
|
|
c4 = _CV_RGB_DIST( p_cur->c, p_next3[1].c );
|
|
|
|
p = p_next1;
|
|
p_next1++;
|
|
|
|
if( c1 > c2 )
|
|
{
|
|
p = p_next1;
|
|
c1 = c2;
|
|
}
|
|
if( c1 > c3 )
|
|
{
|
|
p = p_next3;
|
|
c1 = c3;
|
|
}
|
|
|
|
p_next3++;
|
|
if( c1 > c4 )
|
|
{
|
|
p = p_next3;
|
|
c1 = c4;
|
|
}
|
|
|
|
if( c1 < threshold )
|
|
{
|
|
p_cur->p = p;
|
|
|
|
if( layer == 0 )
|
|
{
|
|
p->a++;
|
|
p_cur = _CV_NEXT_BASE_C3(p_cur,1);
|
|
if( is_last_iter )
|
|
icvMaxRoi1( &(p->rect), j + 1, i );
|
|
}
|
|
else
|
|
{
|
|
int a = p_cur->a;
|
|
|
|
p->a += a;
|
|
p_cur->c.blue = p_cur->c.green = p_cur->c.red = 0;
|
|
p_cur++;
|
|
if( is_last_iter && a != 0 )
|
|
icvMaxRoi( &(p->rect), &(p_cur[-1].rect) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p_cur->p = stub;
|
|
if( is_last_iter /* && ( == 0 || p_cur->a != 0) */ )
|
|
{
|
|
cmp_node.data = p_cur;
|
|
CV_WRITE_SEQ_ELEM( cmp_node, writer );
|
|
}
|
|
if( layer == 0 )
|
|
{
|
|
p_cur = _CV_NEXT_BASE_C3(p_cur,1);
|
|
}
|
|
else
|
|
{
|
|
p_cur->c.blue = p_cur->c.green = p_cur->c.red = 0;
|
|
p_cur++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* clear c's */
|
|
if( layer > 0 )
|
|
{
|
|
p_cur->c.blue = p_cur->c.green = p_cur->c.red = 0;
|
|
p_cur++;
|
|
}
|
|
|
|
if( !(i & 1) )
|
|
{
|
|
p_next1 -= size.width >> 1;
|
|
p_next3 -= size.width >> 1;
|
|
}
|
|
else
|
|
{
|
|
p_next1++;
|
|
p_next3++;
|
|
}
|
|
}
|
|
|
|
return CV_OK;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************************\
|
|
|
|
clusterization segmented components
|
|
|
|
\****************************************************************************************/
|
|
static void
|
|
icvExpandBaseLevelC1( _CvPyramid * base_p, _CvPyramid * p, _CvPyramidBase * start, int width )
|
|
{
|
|
int x = (int)((_CvPyramidBase *) base_p - start);
|
|
int y = x / width;
|
|
|
|
x -= y * width;
|
|
p->a = 1;
|
|
p->rect.x1 = (ushort) x;
|
|
p->rect.y1 = (ushort) y;
|
|
p->rect.x2 = (ushort) (x + 1);
|
|
p->rect.y2 = (ushort) (y + 1);
|
|
p->c = base_p->c;
|
|
}
|
|
|
|
CvStatus
|
|
icvSegmentClusterC1( CvSeq * cmp_seq, CvSeq * res_seq,
|
|
double threshold, _CvPyramid * first_level_end, CvSize first_level_size )
|
|
{
|
|
const double eps = 1.;
|
|
CvSeqWriter writer;
|
|
CvSeqReader reader;
|
|
_CvPyramid temp_cmp;
|
|
_CvPyramidBase *first_level_start = (_CvPyramidBase *) first_level_end -
|
|
first_level_size.width * first_level_size.height;
|
|
int c, i, count = cmp_seq->total;
|
|
|
|
cvStartReadSeq( cmp_seq, &reader, 0 );
|
|
cvStartAppendToSeq( res_seq, &writer );
|
|
|
|
if( threshold < eps )
|
|
{
|
|
/* if threshold is too small then simply copy all
|
|
the components to the output sequence */
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
CvConnectedComp comp;
|
|
_CvPyramid *cmp = (_CvPyramid *) (((_CvListNode *) reader.ptr)->data);
|
|
Cv32suf _c;
|
|
|
|
if( cmp < first_level_end )
|
|
{
|
|
icvExpandBaseLevelC1( cmp, &temp_cmp, first_level_start,
|
|
first_level_size.width );
|
|
cmp = &temp_cmp;
|
|
}
|
|
|
|
_c.i = cvRound( cmp->c );
|
|
cmp->c = _c.f;
|
|
comp.value = cvRealScalar(_c.i);
|
|
comp.area = cmp->a;
|
|
comp.rect.x = cmp->rect.x1;
|
|
comp.rect.y = cmp->rect.y1;
|
|
comp.rect.width = cmp->rect.x2 - cmp->rect.x1;
|
|
comp.rect.height = cmp->rect.y2 - cmp->rect.y1;
|
|
comp.contour = 0;
|
|
|
|
CV_WRITE_SEQ_ELEM( comp, writer );
|
|
CV_NEXT_SEQ_ELEM( sizeof( _CvListNode ), reader );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_CvListNode stub_node;
|
|
_CvListNode *prev = &stub_node;
|
|
|
|
stub_node.next = 0;
|
|
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
_CvListNode *node = (_CvListNode *) reader.ptr;
|
|
|
|
prev->next = node;
|
|
prev = node;
|
|
CV_NEXT_SEQ_ELEM( sizeof( _CvListNode ), reader );
|
|
}
|
|
prev->next = 0;
|
|
prev = stub_node.next;
|
|
|
|
while( prev )
|
|
{
|
|
_CvListNode *node = prev->next;
|
|
_CvListNode *acc = prev;
|
|
_CvPyramid *cmp = (_CvPyramid *) (acc->data);
|
|
CvConnectedComp comp;
|
|
float c0 = cmp->c;
|
|
|
|
if( cmp < first_level_end )
|
|
{
|
|
icvExpandBaseLevelC1( cmp, &temp_cmp, first_level_start,
|
|
first_level_size.width );
|
|
}
|
|
else
|
|
{
|
|
temp_cmp = *cmp;
|
|
temp_cmp.c *= temp_cmp.a;
|
|
}
|
|
|
|
acc->next = 0;
|
|
stub_node.next = 0;
|
|
prev = &stub_node;
|
|
|
|
while( node )
|
|
{
|
|
cmp = (_CvPyramid *) (node->data);
|
|
if( fabs( c0 - cmp->c ) < threshold )
|
|
{
|
|
_CvPyramid temp;
|
|
|
|
/* exclude from global list and add to list of joint component */
|
|
prev->next = node->next;
|
|
node->next = acc;
|
|
acc = node;
|
|
|
|
if( cmp < first_level_end )
|
|
{
|
|
icvExpandBaseLevelC1( cmp, &temp, first_level_start,
|
|
first_level_size.width );
|
|
cmp = &temp;
|
|
}
|
|
|
|
temp_cmp.a += cmp->a;
|
|
temp_cmp.c += cmp->c * cmp->a;
|
|
icvMaxRoi( &(temp_cmp.rect), &(cmp->rect) );
|
|
}
|
|
else
|
|
{
|
|
if( prev == &stub_node )
|
|
{
|
|
stub_node.next = node;
|
|
}
|
|
prev = node;
|
|
}
|
|
node = prev->next;
|
|
}
|
|
|
|
if( temp_cmp.a != 0 )
|
|
{
|
|
c = cvRound( temp_cmp.c / temp_cmp.a );
|
|
}
|
|
else
|
|
{
|
|
c = cvRound( c0 );
|
|
}
|
|
node = acc;
|
|
|
|
while( node )
|
|
{
|
|
Cv32suf _c;
|
|
cmp = (_CvPyramid *) (node->data);
|
|
_c.i = c; cmp->c = _c.f;
|
|
node = node->next;
|
|
}
|
|
|
|
comp.value = cvRealScalar(c);
|
|
comp.area = temp_cmp.a;
|
|
comp.rect.x = temp_cmp.rect.x1;
|
|
comp.rect.y = temp_cmp.rect.y1;
|
|
comp.rect.width = temp_cmp.rect.x2 - temp_cmp.rect.x1;
|
|
comp.rect.height = temp_cmp.rect.y2 - temp_cmp.rect.y1;
|
|
comp.contour = 0;
|
|
|
|
CV_WRITE_SEQ_ELEM( comp, writer );
|
|
prev = stub_node.next;
|
|
}
|
|
}
|
|
|
|
cvEndWriteSeq( &writer );
|
|
return CV_OK;
|
|
}
|
|
|
|
/****************************************************************************************\
|
|
|
|
clusterization segmented components
|
|
|
|
\****************************************************************************************/
|
|
static void
|
|
icvExpandBaseLevelC3( _CvPyramidC3 * base_p, _CvPyramidC3 * p,
|
|
_CvPyramidBaseC3 * start, int width )
|
|
{
|
|
int x = (int)((_CvPyramidBaseC3 *) base_p - start);
|
|
int y = x / width;
|
|
|
|
x -= y * width;
|
|
p->a = 1;
|
|
p->rect.x1 = (ushort) x;
|
|
p->rect.y1 = (ushort) y;
|
|
p->rect.x2 = (ushort) (x + 1);
|
|
p->rect.y2 = (ushort) (y + 1);
|
|
p->c = base_p->c;
|
|
}
|
|
|
|
CvStatus
|
|
icvSegmentClusterC3( CvSeq * cmp_seq, CvSeq * res_seq,
|
|
double threshold,
|
|
_CvPyramidC3 * first_level_end, CvSize first_level_size )
|
|
{
|
|
const double eps = 1.;
|
|
CvSeqWriter writer;
|
|
CvSeqReader reader;
|
|
_CvPyramidC3 temp_cmp;
|
|
_CvPyramidBaseC3 *first_level_start = (_CvPyramidBaseC3 *) first_level_end -
|
|
first_level_size.width * first_level_size.height;
|
|
int i, count = cmp_seq->total;
|
|
int c_blue, c_green, c_red;
|
|
|
|
cvStartReadSeq( cmp_seq, &reader, 0 );
|
|
cvStartAppendToSeq( res_seq, &writer );
|
|
|
|
if( threshold < eps )
|
|
{
|
|
/* if threshold is too small then simply copy all
|
|
the components to the output sequence */
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
CvConnectedComp comp;
|
|
_CvPyramidC3 *cmp = (_CvPyramidC3 *) (((_CvListNode *) reader.ptr)->data);
|
|
Cv32suf _c;
|
|
|
|
if( cmp < first_level_end )
|
|
{
|
|
icvExpandBaseLevelC3( cmp, &temp_cmp, first_level_start,
|
|
first_level_size.width );
|
|
cmp = &temp_cmp;
|
|
}
|
|
|
|
c_blue = cvRound( cmp->c.blue );
|
|
c_green = cvRound( cmp->c.green );
|
|
c_red = cvRound( cmp->c.red );
|
|
_c.i = c_blue; cmp->c.blue = _c.f;
|
|
_c.i = c_green; cmp->c.green = _c.f;
|
|
_c.i = c_red; cmp->c.red = _c.f;
|
|
comp.value = cvScalar( c_blue, c_green, c_red );
|
|
comp.area = cmp->a;
|
|
comp.rect.x = cmp->rect.x1;
|
|
comp.rect.y = cmp->rect.y1;
|
|
comp.rect.width = cmp->rect.x2 - cmp->rect.x1;
|
|
comp.rect.height = cmp->rect.y2 - cmp->rect.y1;
|
|
comp.contour = 0;
|
|
|
|
CV_WRITE_SEQ_ELEM( comp, writer );
|
|
CV_NEXT_SEQ_ELEM( sizeof( _CvListNode ), reader );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_CvListNode stub_node;
|
|
_CvListNode *prev = &stub_node;
|
|
|
|
stub_node.next = 0;
|
|
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
_CvListNode *node = (_CvListNode *) reader.ptr;
|
|
|
|
prev->next = node;
|
|
prev = node;
|
|
CV_NEXT_SEQ_ELEM( sizeof( _CvListNode ), reader );
|
|
}
|
|
prev->next = 0;
|
|
prev = stub_node.next;
|
|
|
|
while( prev )
|
|
{
|
|
_CvListNode *node = prev->next;
|
|
_CvListNode *acc = prev;
|
|
_CvPyramidC3 *cmp = (_CvPyramidC3 *) (acc->data);
|
|
CvConnectedComp comp;
|
|
_CvRGBf c0 = cmp->c;
|
|
|
|
if( cmp < first_level_end )
|
|
{
|
|
icvExpandBaseLevelC3( cmp, &temp_cmp, first_level_start,
|
|
first_level_size.width );
|
|
}
|
|
else
|
|
{
|
|
temp_cmp = *cmp;
|
|
temp_cmp.c.blue *= temp_cmp.a;
|
|
temp_cmp.c.green *= temp_cmp.a;
|
|
temp_cmp.c.red *= temp_cmp.a;
|
|
}
|
|
|
|
acc->next = 0;
|
|
stub_node.next = 0;
|
|
prev = &stub_node;
|
|
|
|
while( node )
|
|
{
|
|
cmp = (_CvPyramidC3 *) (node->data);
|
|
if( _CV_RGB_DIST( c0, cmp->c ) < threshold )
|
|
{
|
|
_CvPyramidC3 temp;
|
|
|
|
/* exclude from global list and add to list of joint component */
|
|
prev->next = node->next;
|
|
node->next = acc;
|
|
acc = node;
|
|
|
|
if( cmp < first_level_end )
|
|
{
|
|
icvExpandBaseLevelC3( cmp, &temp, first_level_start,
|
|
first_level_size.width );
|
|
cmp = &temp;
|
|
}
|
|
|
|
temp_cmp.a += cmp->a;
|
|
temp_cmp.c.blue += cmp->c.blue * cmp->a;
|
|
temp_cmp.c.green += cmp->c.green * cmp->a;
|
|
temp_cmp.c.red += cmp->c.red * cmp->a;
|
|
icvMaxRoi( &(temp_cmp.rect), &(cmp->rect) );
|
|
}
|
|
else
|
|
{
|
|
if( prev == &stub_node )
|
|
{
|
|
stub_node.next = node;
|
|
}
|
|
prev = node;
|
|
}
|
|
node = prev->next;
|
|
}
|
|
|
|
if( temp_cmp.a != 0 )
|
|
{
|
|
c_blue = cvRound( temp_cmp.c.blue / temp_cmp.a );
|
|
c_green = cvRound( temp_cmp.c.green / temp_cmp.a );
|
|
c_red = cvRound( temp_cmp.c.red / temp_cmp.a );
|
|
}
|
|
else
|
|
{
|
|
c_blue = cvRound( c0.blue );
|
|
c_green = cvRound( c0.green );
|
|
c_red = cvRound( c0.red );
|
|
}
|
|
node = acc;
|
|
|
|
while( node )
|
|
{
|
|
Cv32suf _c;
|
|
cmp = (_CvPyramidC3 *) (node->data);
|
|
_c.i = c_blue; cmp->c.blue = _c.f;
|
|
_c.i = c_green; cmp->c.green = _c.f;
|
|
_c.i = c_red; cmp->c.red = _c.f;
|
|
node = node->next;
|
|
}
|
|
|
|
comp.value = cvScalar( c_blue, c_green, c_red );
|
|
comp.area = temp_cmp.a;
|
|
comp.rect.x = temp_cmp.rect.x1;
|
|
comp.rect.y = temp_cmp.rect.y1;
|
|
comp.rect.width = temp_cmp.rect.x2 - temp_cmp.rect.x1;
|
|
comp.rect.height = temp_cmp.rect.y2 - temp_cmp.rect.y1;
|
|
comp.contour = 0;
|
|
|
|
CV_WRITE_SEQ_ELEM( comp, writer );
|
|
prev = stub_node.next;
|
|
}
|
|
}
|
|
|
|
cvEndWriteSeq( &writer );
|
|
return CV_OK;
|
|
}
|
|
|
|
/****************************************************************************************\
|
|
|
|
definition of the maximum roi size
|
|
|
|
\****************************************************************************************/
|
|
void
|
|
icvMaxRoi( _CvRect16u * max_rect, _CvRect16u * cur_rect )
|
|
{
|
|
if( max_rect->x2 == 0 )
|
|
*max_rect = *cur_rect;
|
|
else
|
|
{
|
|
if( max_rect->x1 > cur_rect->x1 )
|
|
max_rect->x1 = cur_rect->x1;
|
|
if( max_rect->y1 > cur_rect->y1 )
|
|
max_rect->y1 = cur_rect->y1;
|
|
|
|
if( max_rect->x2 < cur_rect->x2 )
|
|
max_rect->x2 = cur_rect->x2;
|
|
if( max_rect->y2 < cur_rect->y2 )
|
|
max_rect->y2 = cur_rect->y2;
|
|
}
|
|
}
|
|
|
|
void
|
|
icvMaxRoi1( _CvRect16u * max_rect, int x, int y )
|
|
{
|
|
if( max_rect->x2 == 0 )
|
|
{
|
|
max_rect->x1 = (ushort) x;
|
|
max_rect->y1 = (ushort) y;
|
|
|
|
++x;
|
|
++y;
|
|
|
|
max_rect->x2 = (ushort) x;
|
|
max_rect->y2 = (ushort) y;
|
|
}
|
|
else
|
|
{
|
|
if( max_rect->x1 > x )
|
|
max_rect->x1 = (ushort) x;
|
|
if( max_rect->y1 > y )
|
|
max_rect->y1 = (ushort) y;
|
|
|
|
++x;
|
|
++y;
|
|
|
|
if( max_rect->x2 < x )
|
|
max_rect->x2 = (ushort) x;
|
|
if( max_rect->y2 < y )
|
|
max_rect->y2 = (ushort) y;
|
|
}
|
|
}
|
|
|
|
|
|
/*F///////////////////////////////////////////////////////////////////////////////////////
|
|
// Name: cvPyrSegmentation
|
|
// Purpose:
|
|
// segments an image using pyramid-linking technique
|
|
// Context:
|
|
// Parameters:
|
|
// src - source image
|
|
// dst - destination image
|
|
// comp - pointer to returned connected component sequence
|
|
// storage - where the sequence is stored
|
|
// level - maximal pyramid level
|
|
// threshold1 - first threshold, affecting on detalization level when pyramid
|
|
// is built.
|
|
// threshold2 - second threshold - affects on final components merging.
|
|
// Returns:
|
|
// Notes:
|
|
// Source and destination image must be equal types and channels
|
|
//F*/
|
|
CV_IMPL void
|
|
cvPyrSegmentation( IplImage * src,
|
|
IplImage * dst,
|
|
CvMemStorage * storage,
|
|
CvSeq ** comp, int level, double threshold1, double threshold2 )
|
|
{
|
|
CvSize src_size, dst_size;
|
|
uchar *src_data = 0;
|
|
uchar *dst_data = 0;
|
|
int src_step = 0, dst_step = 0;
|
|
int thresh1 = cvRound( threshold1 );
|
|
int thresh2 = cvRound( threshold2 );
|
|
|
|
if( src->depth != IPL_DEPTH_8U )
|
|
CV_Error( CV_BadDepth, "Unsupported format" );
|
|
|
|
if( src->depth != dst->depth || src->nChannels != dst->nChannels )
|
|
CV_Error( CV_StsBadArg, "src and dst have different formats" );
|
|
|
|
cvGetRawData( src, &src_data, &src_step, &src_size );
|
|
cvGetRawData( dst, &dst_data, &dst_step, &dst_size );
|
|
|
|
if( src_size.width != dst_size.width ||
|
|
src_size.height != dst_size.height )
|
|
CV_Error( CV_StsBadArg, "src and dst have different ROIs" );
|
|
|
|
switch (src->nChannels)
|
|
{
|
|
case 1:
|
|
IPPI_CALL( icvPyrSegmentation8uC1R( src_data, src_step,
|
|
dst_data, dst_step,
|
|
src_size,
|
|
CV_GAUSSIAN_5x5,
|
|
comp, storage, level, thresh1, thresh2 ));
|
|
break;
|
|
case 3:
|
|
IPPI_CALL( icvPyrSegmentation8uC3R( src_data, src_step,
|
|
dst_data, dst_step,
|
|
src_size,
|
|
CV_GAUSSIAN_5x5,
|
|
comp, storage, level, thresh1, thresh2 ));
|
|
break;
|
|
default:
|
|
CV_Error( CV_BadNumChannels, "Unsupported format" );
|
|
}
|
|
}
|
|
|
|
|
|
/* End of file. */
|